[analyzer] ConditionBRVisitor: Enhance to write out more information

[Charusso]

Summary

Add extra messages to the bug report to inform the user why the analyzer
Taking true/false branch.

[Charusso]

Added the mentioned second diff.

[Szelethus]

I'm sadly not that knowledgeable on visitors to help you, but the idea is awesome, thank you for working on this!

[george.karpenkov]

The change makes sense to me, but:

1. Note that "Assuming X" directives are useful for the analyzer developers, since they know that's where the checker makes arbitrary assumptions, but to end users that mostly feels like noise ("Taking true branch" is there already, why there should be "Assuming 'i' is > 0" as well?)

2. @NoQ do you know why the GDM comparison was there in the first place? The commit was made by Ted in 2011, maybe constraint changes had to be reflected in the GDM at that point (?)

[Charusso]

In D53076#1260663, @george.karpenkov wrote:

The change makes sense to me, but:

1. Note that "Assuming X" directives are useful for the analyzer developers, since they know that's where the checker makes arbitrary assumptions, but to end users that mostly feels like noise ("Taking true branch" is there already, why there should be "Assuming 'i' is > 0" as well?)

2. @NoQ do you know why the GDM comparison was there in the first place? The commit was made by Ted in 2011, maybe constraint changes had to be reflected in the GDM at that point (?)

Based on @baloghadamsoftware's idea (D34508) the main goal is to print out trivial values for the Clang SA, but lot of time consuming nonsense for developers. As you mentioned it is bad to have multiple assumptions, but half of the reporters behave like that, and the other half does not print any/useful information.

That two separate project based on that current project: create the reports, and make the style identical, so that we could enhance them. The best example here is test/Analysis/diagnostics/macros.cpp: on line 27 you could see the message Assuming the condition is true but the upper conditions miss this report.

[NoQ]

In D53076#1260663, @george.karpenkov wrote:

1. Note that "Assuming X" directives are useful for the analyzer developers, since they know that's where the checker makes arbitrary assumptions, but to end users that mostly feels like noise ("Taking true branch" is there already, why there should be "Assuming 'i' is > 0" as well?)

I believe that distinction between "Assuming..." (event piece, yellow bar in scan-build) and "Taking..." (control-flow piece, grey bar in scan-build, depicted with arrows without text in a number of other UIs) is useful for the users as well, not just for hackers. I agree that the distinction isn't obvious and for now this part of the UI is not very useful. But now that you're at it, i think it'd be better to fix this problem by making diagnostics more understandable rather than by simplifying out the distinction.

For example, in the inline-plist.c's bar() on line 45, Static Analyzer indeed doesn't assume that p is equal to null; instead, Static Analyzer *knows* it for sure. There's no guess made here, and that's not an assumption that the user would need to agree or disagree with while looking at the report. Instead, it is an inevitable consequence of the previous events that occurred on this path. So i guess we could say something like "Knowing that 'p' is equal to null" or "'p' is inevitably null" and it should make the distinction apparent to the user. The user would notice that there's a change in the way we're talking about the fact.

The other reason why it's important is that those arbitrary assumptions are one of the fundamental weakness of the technique behind Static Analyzer: the user is indeed allowed to disagree with these assumptions and then mark the positive as false and suppress it with an assertion. In a code with a single branch such approach works fine because it is based on "presumption of no deadcode" (i.e., if there's an if in the code, both branches should be reached sometimes), but when there are N consequent branches, it is not necessary for all 2^N possible execution paths to be feasible: an O(N) number of paths can cover all the branches. But when it comes to actual facts that are inevitably true after the user has agreed with all previous assumptions on the path, the user can't disagree with those facts anymore, and that's an important piece of info to convey.

In D53076#1260663, @george.karpenkov wrote:

2. @NoQ do you know why the GDM comparison was there in the first place? The commit was made by Ted in 2011, maybe constraint changes had to be reflected in the GDM at that point (?)

It's likely that back then GDM only contained constraints and checker info (and program point kind guaranteed that checker info could not have changed). But that's not the case anymore (we have more core traits - dynamic type info, C++ constructor support, taint, etc.), so this code is definitely incorrect; not sure how often does it matter. In order to produce an actual "correct" logic (correct in the sense that it preserves the old, pre-patch behavior), we probably need to add a method to ConstraintManager to ask whether constraints have changed between two states.

[Charusso]

• Fixed the duplicated reports.
• Removed the EndPath function what is remained somehow and confused me.

[Charusso]

In D53076#1261134, @NoQ wrote:

For example, in the inline-plist.c's bar() on line 45, Static Analyzer indeed doesn't assume that p is equal to null; instead, Static Analyzer *knows* it for sure.

Thanks you! This is a great example what I have to cover later on. I have a patch where we print out known integers. The basic style is the following: Assuming 'x' is not equal to 1. I would like to emphasize the value and if it a known value, make it looks like this: Variable 'x' is equal to '1', or Variable '*ptr' is equal to '1'. (If this is the situation: Constant 'x' is equal to '1' would be cool as well.)

I made that patch in a separated file called BugReporterHelpers.cpp next to the BugReporterVisitors. I also would like to move all the helper functions from BugReporterVisitors.cpp to that source file. My first idea with that to create a live documentation, how would a new clang-hacker obtain a value from a certain position (me with testing those things out). Also what you mentioned with this flow-sensitive chaining, this is could not be a short patch, so I think this is the time when we want to have something like this.

What do you think? If this patch goes well, should I attach the mentioned new patch to this, or create a new one?

[george.karpenkov]

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

80 ↗

(On Diff #170314)

Traditionally LLVM projects use llvm::DenseMap

183 ↗

(On Diff #170314)

return Constraints.insert(make_pair(Cond, Message)).second ?

[george.karpenkov]

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

202 ↗

(On Diff #170314)

These constraints are conceptually part of the visitor, not part of the constraint manager. Could they be simply stored in the visitor?

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

235 ↗

(On Diff #170314)

Probably should be replaced by the expression above and inlined.

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

189

spurious change

1832

capital letter

[Szelethus]

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

182 ↗

(On Diff #170314)

I would not expect a function called isChanged to change the state of an object. Can you find a name that doesn't feel like it's a simple getter function?

[Charusso]

Refactor.

[whisperity]

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

238 ↗

(On Diff #170808)

insertOrUpdateContraintMessage

and mention in the documentation that it returns whether or not the actual insertion or update change took place

[george.karpenkov]

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

80 ↗

(On Diff #170808)

Generally, StringRef's shouldn't be stored in containers, as containers might outlive them.
It might be fine in this case, but I would prefer to be on the safe side and just use std::string

238 ↗

(On Diff #170808)

If constraints is now a property of the visitor, shouldn't this method with the typedef above be moved to the visitor as well?

244 ↗

(On Diff #170808)

Isn't that equivalent to Constraints.insert(make_pair(Cond, Message)).second ?
I think I have written that before.

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

2212

It does not seem necessary, because a new copy of the visitor is created for each new bug report.

[Charusso]

More refactor.

[Charusso]

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

202 ↗

(On Diff #170314)

My idea was to have a generic constraint map as @NoQ mentioned, then we could attach this to other places to reduce noisy reports. But probably this is the best place for now.

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

244 ↗

(On Diff #170808)

We have multiple messages at the same place so we have to update the message. The problem with your code is insert operates with disjunct keys, not values.

[george.karpenkov]

Thanks a lot, this is almost ready!
I think it should be good to go after this round of nitpicks.

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

168 ↗

(On Diff #171037)

From a brief inspection this indeed seems dead code. However, this removal should be moved into a separate revision (sorry!)

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

680 ↗

(On Diff #171037)

Same: should be moved into a separate revision, same as the other removal.

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

1844

How do we know that it's always an Expr?

1845

/*tookTrue=*/tag == tag.first

1952

1. What about the refactoring I have previously suggested twice?
2. I know you have started with that -- and sorry for spurious changes -- but I also think your original name of constraintsChanged is better.

lib/StaticAnalyzer/Core/ExprEngine.cpp

2261 ↗

(On Diff #171037)

Should be moved together with other two removals.

lib/StaticAnalyzer/Core/ProgramState.cpp

29 ↗

(On Diff #171037)

While this minor formatting is correct, it's better to remove it to simplify future archaeology.

[Charusso]

Removed the unnecessary changes.

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

1844

VisitTrueTest operates with Expr only, so I just left the type.

1952

We have multiple messages at the same place so we have to update the message. The problem with your code is insert operates with disjunct keys, not values.

I have commented this after the last refactor, sorry for the inconvenience.

[Charusso]

Thanks everyone for the review!

@george.karpenkov could you commit it please? I am interested in your ideas in the little discussion started with @NoQ at the beginning of the project.

[george.karpenkov]

Actually, apologies again: I have rushed through this too much.
@NoQ has a good point: we need to preserve the distinction between the things analyzer "assumes" and the things analyzer "knows".

[NoQ]

I mean, the idea of checking constraints instead of matching program points is generally good, but the example i gave above suggests that there's a bug somewhere.

[Charusso]

In D53076#1276270, @george.karpenkov wrote:

@NoQ has a good point: we need to preserve the distinction between the things analyzer "assumes" and the things analyzer "knows".

Yes, but I think it should be a new patch because I would like to add a value-dump method on integers/booleans and stuff I already mentioned in the beginning.

[Charusso]

In D53076#1276277, @NoQ wrote:

I mean, the idea of checking constraints instead of matching program points is generally good, but the example i gave above suggests that there's a bug somewhere.

I think it is an unimplemented feature which appear like 1:500 time, but we will see.

[NoQ]

In D53076#1276315, @Charusso wrote:

In D53076#1276277, @NoQ wrote:

I mean, the idea of checking constraints instead of matching program points is generally good, but the example i gave above suggests that there's a bug somewhere.

I think it is an unimplemented feature which appear like 1:500 time, but we will see.

The original behavior is perfectly consistent with my understanding of Static Analyzer's reports that i've been reading continuously for years. There might have been a few places where assumption is made but isn't highlighted, but the opposite has never happened, and also the opposite is more confusing to the user because it demonstrates an explicit text that the user has to trust. So i think that one way or another, the new behavior is a regression from the original behavior on an on-by-default functionality on some test cases, and we should not commit this patch until this regression is debugged and fixed.

I highlight a few more test cases that i believe have regressed in inline comments.

test/Analysis/MisusedMovedObject.cpp

187–188

These assumptions were already made on the previous branches. There should be no extra assumptions here.

221

We have assumed that i is >= 10 on the previous branch. It imples that i is greater than 5, so no additional assumption is being made here.

test/Analysis/NewDelete-path-notes.cpp

10–11

Static Analyzer knows that the standard operator new never returns null. Therefore no assumption is being made here.

test/Analysis/diagnostics/macros.cpp

36–37

This one's good. Static Analyzer doesn't understand floats, so this branch is indeed non-trivial. There should indeed be an assuming... piece here.

test/Analysis/diagnostics/no-store-func-path-notes.cpp

23–24

This method is called from use() with param equal to concrete 0. It is not analyzed as a top-level function. There is no assumption made here, like in most other places in this file.

test/Analysis/diagnostics/no-store-func-path-notes.m

13–14

This method is called from foo() with param equal to concrete 0. It is not analyzed as a top-level function. There is no assumption made here.

26–27

-initVar returns concrete 0 when called with these parameters. There is no assumption being made here.

34–35

This function is called from inifFromBlock() with x equal to concrete 0. It is not analyzed as a top-level function. Therefore, no assumption is being made here.

test/Analysis/inline-plist.c

46–47

The condition !!p above being assumed to false ensures that p is equal to null here. We are not assuming it again here.

test/Analysis/uninit-vals.m

167–168

These are pretty weird. As far as i understand the test, these should be there. But i'm suddenly unable to debug why were they not shown before, because there's either something wrong with exploded graph dumps or with the exploded graph itself; it appears to be missing an edge right after size > 0 is assumed. I'll look more into those.

[Charusso]

Added a function to write out known integers and booleans.

test/Analysis/MisusedMovedObject.cpp

187–188

Agree but only if there is no extra constraint EventPiece between them.

221

Agree but only if there is no extra constraint EventPiece between them.

test/Analysis/NewDelete-path-notes.cpp

10–11

As I see SA knows nothing. Where to teach it?

test/Analysis/inline-plist.c

46–47

Agree but only if there is no extra constraint EventPiece between them.

[Charusso]

test/Analysis/Inputs/expected-plists/cxx-for-range.cpp.plist

837

Double negating is not in standard English, so this behaviour is documented here.

test/Analysis/Inputs/expected-plists/edges-new.mm.plist

9658

@NoQ this is the only place (as I see) where SA works with flow-sensitive constraint-handling what you mentioned. Is it a good change?

[NoQ]

@Charusso, i believe you have some misconception about what constraints mean and how they work. Not sure what this misconception is, so i'll make a blind guess and annoy you a little bit with a narcissistic rant and you'll have to bear me, sry!

The most important thing to know about constraints is that they are applied to "symbols", not to variables. We explain it to the user in terms of variables (when possible) because symbols are immaterial in the code and as such cannot be easily explained to the user, but in reality constraints are entirely about symbols.

Let me explain this with an example. If you say "let x denote the number of sheep in a herd" and then a new sheep is born and joins the herd, the number of sheep becomes (x + 1) and no longer remains equal to x, while x can still be used to represent the *original* number of sheep. In this example, the number of sheep is the variable, and x is the symbol.

The good thing about symbols is that they denote the same unknown value throughout the whole analysis. Values of variables may change (hence the nomenclature), but values denoted by symbols never change. They are kinda like Static Analyzer's substitute for transforming the program into SSA notation. When constraints are assumed, we make assumptions about the unknown value denoted by the symbol and it becomes "less unknown", but it is still the same value, it's just we know more about it. Which means that:

• "The Golden Rule of Constraint Solving": (i came up with this title 3 seconds ago) In any two points A and B during analysis (i.e., nodes in the exploded graph), if A precedes B along any execution path (i.e., there's a directed path from A to B in the exploded graph), constraints for any symbol x in point B are a subset of constraints for x in point A.

For example, if Static Analyzer assumes that a symbol x is greater than 10, it cannot later assume that x is less than 5, because [-∞, 4] is not a subset of [11, +∞]. Therefore Static Analyzer will not explore the path on which x is less than 5, and it will not update range constraints for the symbol. But it will explore the path on which x is also less than 15 by setting range constraints for x to [11, 14] because [11, 14] is indeed a subset of [11, +∞].

The formal definition of "Assuming" pieces is that they indicate that the constraints change for the symbol (eg., for the symbol that represents the *current* value of the variable mentioned in the message of the event piece). This is the precise meaning of "Static Analyzer is assuming". And when explained in terms of variables, this precise meaning is comprehend-able by the user and should be conveyed properly. The distinction between presence and absence of assumptions is crucial to convey. Therefore, if the branch condition is denoted by a symbol and constraints over that symbol do not change, there should be no "Assuming..." piece for the branch condition symbol, and the respective mechanism should not be removed. But there may be a new sort of event piece, eg. "Knowing...", if you still want to highlight the motivation behind "Taking..." a specific branch, which seems to be the purpose of your patch.

"Assuming..." pieces over the same variable may contradict each other (i.e., look as if they violate the Golden Rule) when contents of the variable change. So, yeah, in this case another "Assuming..." piece will be necessary in some cases. But it doesn't mean that the Golden Rule is actually violated; it just means that the variable now has different value and different assumptions can be made about it. This doesn't happen in the examples that i pointed out, so there should not be an "Assuming..." piece.

In an inline comment i show what this means on the test case that seems to be the easiest.

test/Analysis/MisusedMovedObject.cpp

187–188

I think i answered this concern in the out-of-line comment. Because constraints never change in a contradictory manner but only grow shorter, a much stronger statement can be made here: there are also no extra assumptions when the variable is not reassigned since the last "Assuming..." piece. Of course, even if it is reassigned, we may still not want to have the "Assuming..." piece - it depends entirely on the current constraints over the symbol that represents the branch condition.

test/Analysis/NewDelete-path-notes.cpp

10–11

It does know it. The ultimate way to observe what Static Analyzer knows or thinks at any point during analysis and how its knowledge evolves is to dump the "exploded graph":

As you see, as soon as operator new is evaluated, even before the if-statement is evaluated, the symbol conj_$0{int, LC1, S772, #1} that represents the unknown value of the pointer produced by operator new becomes constrained to [1, 2⁶⁴ - 1] (assuming the target system is 64-bit), which means exactly that: it can take any value except 0.

Therefore when Static Analyzer reaches the if-statement later, it has no choice but to proceed to the true-branch, and not only the false branch is entirely skipped (the execution path doesn't split in two), but also the set of constraints remains unchanged, indicating that no assumption is being made:

For the reference, here's the complete exploded graph for the test:

graph.svg66 KBDownload

[Charusso]

• Implemented a 'look forward' feature to see if the constraint changed.
• Removed known value printing.
• Removed 'Assuming...' pieces where the condition is known to be true.
• Side effect: too many generic assumption message.

[Charusso]

@NoQ thanks you for the great explanation! I really wanted to write out known constant integers and booleans but I think 'Knowing...' pieces would be more cool.

I tried to minimize the changes after a little e-mailing with @george.karpenkov on the mailing list. The problem is the following: we go backwards on the bug-path, that is why we see range information changes backwards, but the user information goes forwards: from the top to the bottom. I have implemented the 'check upwards' feature, so now everything working fine, but I think it is a very time-consuming approach. (The idea is copied from BugReporter.cpp/generateVisitorsDiagnostics() where I tried to flip the path, unsuccessfully: http://clang-developers.42468.n3.nabble.com/Visit-nodes-in-the-order-of-the-user-output-to-create-better-reports-td4062898.html )

[Charusso]

test/Analysis/diagnostics/macros.cpp

36–37

A little bit misunderstandable, because we do not know anything about doubles. May the generic message fit better?

test/Analysis/diagnostics/undef-value-param.m

56 ↗

(On Diff #174750)

I am not sure why but the range here [1, (2^64)-1]. There is would not be any number like 0?

test/Analysis/new-ctor-malloc.cpp

12–13

The range information is [1, (2^64)-1] but as I saw malloc could return null. Who is lying here?

test/Analysis/uninit-vals.m

167–168

We gather information with clang-analyzer-eval functions so the conditions would be Knowing... pieces but the BugReporter.cpp does not know about these extra assumptations. Where to teach to do not Assuming..., but Knowing... these?

test/Analysis/virtualcall.cpp

172

Because this X x(i - 1); we assume these conditions? This one is tricky to be Knowing....

[Szelethus]

In the meanwhile we managed to figure out where the problem lays, so if you're interested, I'm going to document it here.

The problem this patch attempts to solve is that ConditionBRVisitor adds event pieces to the bugpath when the state has changed from the previous state, not only when the ConstraintManager differs in between the changes [1]. The patch attempts to solve this by inspecting the actual condition, and tries to find out whether the symbols inside that condition has changed in between the states, but this is overkill solution, as comparing the two ConstraintManager objects would achieve the same thing. This should probably be executed by extending the interface of ConstraintManager with a comparison method.

[1] https://github.com/llvm-mirror/clang/blob/master/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp#L1808

[Charusso]

In D53076#1305209, @Szelethus wrote:

In the meanwhile we managed to figure out where the problem lays, so if you're interested, I'm going to document it here.

The patch attempts to solve this by inspecting the actual condition, and tries to find out whether the symbols inside that condition has changed in between the states, but this is overkill solution, as comparing the two ConstraintManager objects would achieve the same thing.

I tried to investigate what is happening after we entered into a condition, which is working well with 'Knowing...' pieces, but with too much overhead. Because this patch is all about write out more information, rather than removing the GDM-checking I will move forward with 'Knowing...' pieces. The current questions are real for that project, just let me simplify the code and create that feature.

[Charusso]

• Better approach to prevent duplicated report messages.

Side effects:

• Because we rely on constraint range information we measure the bounds with equality operators so lost precision, but now the style of the reports is identical.
• We create Assuming... pieces on unknown values where generic message has not shown up.

[Charusso]

Sorry for the huge noise! It took me a while to see what is the problem.

[Szelethus]

I think the reason why the printed message was either along the lines of "this is 0" and "this is non-0", is that we don't necessarily know what constraint solver we're using, and adding more non-general code BugReporter is most probably a bad approach. How about we tinker with ContraintManager a little more, maybe add an explainValueOfVarDecl, that would return the value of a variable in a given ProgramState? We could implement it for RangeConstraintSolver (essentially move the code you already wrote there), and leave a TODO with a super generic implementation for Z3.

Although, I can't quite write an essay on top of my head about golden rules of constraint solving, so take my advice with a grain of salt.

include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h

164 ↗

(On Diff #175177)

We only get to know what this field is for while reading the actual implementation, please add comments.

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

1829–1857

ConstraintRange, as far as I know, is the data RangedConstraintManager stores in the GDM. What if we're using a different constraint solver? I think it'd be better to take the more abstract approach, extend ConstraintManager's interface with an isEqual or operator== pure virtual method, and implement it within it's descendants.

[Charusso]

• The final piece of that puzzle: apply extra Assuming... pieces without the generic message. (A little bit too many.)

• Comment on IsAssuming.

[Charusso]

@Szelethus thanks you for the comments!

In D53076#1307336, @Szelethus wrote:

I think the reason why the printed message was either along the lines of "this is 0" and "this is non-0", is that we don't necessarily know what constraint solver we're using, and adding more non-general code BugReporter is most probably a bad approach.

It was an unimplemented feature to write out known stuff. There is no constraint solving, it is rather constant value dumping.

How about we tinker with ContraintManager a little more, maybe add an explainValueOfVarDecl, that would return the value of a variable in a given ProgramState? We could implement it for RangeConstraintSolver (essentially move the code you already wrote there), and leave a TODO with a super generic implementation for Z3.

I agree with @george.karpenkov, we want to have the smallest scope.

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

1829–1857

Because we only operate in the ConditionBRVisitor it would be useless for now.

[george.karpenkov]

This looks more reasonable, thanks!
What about just dropping the Knowing prefix?
Just having arr is null, taking true branch seems considerably more readable.

[george.karpenkov]

test/Analysis/uninit-vals.m

221–222

Same here: we should know that testObj->size == 0

323–324

That does not seem right: from calloc the analyzer should know that the testObj->size is actually zero.

test/Analysis/virtualcall.cpp

170

Could you describe what happens here?
Why the assuming notes weren't there before?

[Charusso]

@george.karpenkov thanks you for the comments!

In D53076#1308641, @george.karpenkov wrote:

What about just dropping the Knowing prefix?
Just having arr is null, taking true branch seems considerably more readable.

I wanted to create something identical to the current reports. If we are about to change readability, I would change that two first:

• identical operator printing with <, <=, >..., so equal to is = and not equal to is !=.
• emphasize the value information with quotes, so Assuming 'i' >= '2'.

test/Analysis/uninit-vals.m

323–324

That Assuming... piece is rely on the change between the last two diffs: I just print out more VarDecls in patternMatch(). I thought everything works fine, so I will check that problem if @NoQ will not be faster as he already found some problematic code piece in that test file.

test/Analysis/virtualcall.cpp

170

We do not have range information in the *newly seen Assuming... pieces. Because the analyzer has not learnt new information - as there is no information - we have not entered to VisitTrueTest() to report these. A good reference for that new behaviour is in test/Analysis/Inputs/expected-plists/cxx-for-range.cpp.plist.

*I have added these with https://reviews.llvm.org/D53076?id=175177

[NoQ]

There still seem to be a couple of regressions with Assuming... pieces, but other than that, i believe that an awesome piece of progress has been made here. I really like how it looks now. I agree with George that dropping "Knowing" from the message looks fancier.

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

92–102

The usual style in LLVM for this sort of stuff is

if (const auto *DRE = dyn_cast_or_null<DeclRefExpr>(CondVarExpr)) {
  // Do stuff with DRE.
}

CondVarExpr definitely cannot successfully cast to both DeclRefExpr and BinaryOperator at the same time, so this sort of structure is much easier to understand. Also checks after && are definitely redundant.

122

Hmm, why are you even able to access it here? The get<> key should only be visible in a single translation unit in which it is defined, otherwise it's buggy because it relies on addresses of static globals to work.

Actually, could you separate the work of displaying the exact range boundary (this whole RangeSet business) into a separate diff? I think it's a separate change that requires separate discussion.

Also instead of accessing the constraint manager's private trait directly, you should use the getRange() method. It adds all the necessary implicit assumptions that aren't represented explicitly as items in the map.

133

Why int?

That's not what getExtValue() returns (so you can accidentally print a truncated value), and generally the size of the int type on the host machine shouldn't affect analysis results.

I think you should print the APSInt directly instead of converting it into a raw integer.

137–139

Even if the Store is currently null, every live variable in the program inevitably has a value, so i don't think we should bail out here.

146–148

There are cornercases where the range consists of exactly one point, so the value is technically concrete but wasn't yet collapsed into a concrete value by the engine.

In any case, as far as i understand, this code is there only for optimization, and i don't think it's actually making things faster because the lookup is already expensive.

151

auto shouldn't be used here and in a few other places according to the coding guidelines.

Essentially, it should only be used for cast results, where the type is already written out.

153

What do you mean by "inline"? There are no function calls going on here.

1822–1823

I'm worried that checker transitions can screw up the order of nodes here.

Every time a checker does addTransition() or generateNonFatalErrorNode(), it injects an intermediate node, and there can be indefinitely many of those between the nodes you're actually looking for.

You should probably rely on program points instead, i.e. "this is the node in which the terminator condition was evaluated", "this is the node in which we jumped from one CFG block to another".

2129

Did you mean ->end()->To()? We need a test in which the RangeSet contains more than one range.

test/Analysis/diagnostics/macros.cpp

36–37

Yup, the generic message should be perfectly fine, but i also don't see any problems with the non-generic message, as it is "technically the truth".

test/Analysis/diagnostics/undef-value-param.m

56 ↗

(On Diff #174750)

That's suspicious, could you have a look at when exactly does this range appear? There should be an Assuming... piece here. I suspect that you might be looking at the state after the split, which already has the range, and not looking at the state before the split, which doesn't have the range.

test/Analysis/new-ctor-malloc.cpp

12–13

Yes, malloc is nullable. There should be an Assuming... piece here. It's probably the same problem that we had with anotherCreateRef().

test/Analysis/uninit-vals.m

167–168

Aha, i see.

testObj->size evaluates to pure UnknownVal because region store cannot deal with two overlapping lazy bindings (which is the whole point of the test).

Therefore no new constraints are added. So we cannot figure out what happens by looking at the constraints.

So it's roughly the same thing that happened in the example with floats.

We should just outright always add an "Assuming..." piece when the condition evaluates to Unknown. The new behavior is correct here.

323–324

testObj->size is an UnknownVal at this point (see the parallel comment on the older revision's thread). So there should be an Assuming... piece here. Ultimately there shouldn't, but throwing an Assuming... piece is the correct behavior for the sub-system that decides whether an Assuming... piece should be emitted.

test/Analysis/virtualcall.cpp

172

These are the notes for X x1(1); in main. In this case i is a concrete value: exactly 1 on the first iteration and exactly 0 on the second iteration.

The new behavior is incorrect; there should not be an Assuming... piece here.

[Charusso]

• Better way to measure if the value is known.
• Moved extra Assuming... pieces into a different patch (D57410).
• New generic assumptions created on known MemberExprs and entire conditions.

• Side effect: ninja check-clang-analyzer-z3 passes without the error mentioned in D54811. ("Like magic and unicorns?")

TODO list for upcoming patches:

• Removed bounds checking with RangeSets.
• Removed bool value support.
• Removed MemberExpr value support.

[Charusso]

Thanks you @NoQ! Luckily it is rely on ProgramPoints now. The only problem as I see the mentioned Z3-test, where I have no idea what happened.

[NoQ]

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

173–180

I'll take a closer look at the rest of the patch, but this code snippet looks suspicious to me at a glance. Does it ever add anything on top of the "hard-coded" case? When it does, is it correct?

I mean, the "hard-coded" case does not actually correspond to an integer literal expression; it corresponds to any circumstances in which the Static Analyzer could compute that the value is going to be exactly that concrete integer on this execution path. If the Static Analyzer could not compute that, i doubt that this simple procedure will do better.

It might be that this is needed because you're looking at a wrong ExplodedNode on which the condition expression is either not computed yet or already dropped. In this case i'd prefer to try harder to find the right node, because getSVal(CondVarExpr, LCtx) is just so much more powerful.

[Charusso]

• Rebased.
• Removed DeclRefExpr part from getConcreteIntegerValue().
• Added constant integer early-return.

[Charusso]

• Added back DeclRefExpr part to getConcreteIntegerValue() for proof by example.

[Charusso]

• Generic known condition evaluations.
• check-clang-analyzer-z3 passes as expected:

Failing Tests (1):
    Clang :: Analysis/plist-macros.cpp

  Expected Passes    : 565
  Expected Failures  : 2
  Unsupported Tests  : 3
  Unexpected Failures: 1

[NoQ]

I'll take a closer look in a few days, sorry for the delays! The progress you're making is fantastic and i really appreciate your work, but i have an urgent piece of work of my own to deal with this week.

[Charusso]

In D53076#1403436, @NoQ wrote:

I'll take a closer look in a few days, sorry for the delays! The progress you're making is fantastic and i really appreciate your work, but i have an urgent piece of work of my own to deal with this week.

@NoQ, please take your time, that new bug-report logic is the end of my work on reporting business (as I mentioned I wanted to create the same patch), so that is more important than this.

[Charusso]

• Rebased.

[NoQ]

Btw, did you try running this patch against big projects? 'Cause it's a high-impact change and we'd have to be careful with it.

I ran it on LLVM real quick and noticed that 97.3% (!) of reports contained at least one of the new notes, with number of HTML path pieces increased by 23.7% on average (note that the impact on plist reports would be much higher because they don't have any text for gray pieces).

I'll try to get back with some actual hand-picked examples to demonstrate my impressions. My overall feel was that it increases quality of life quite a bit by reducing the amount of time spent scrolling and jumping around the report - the necessary information becomes available exactly where you need it and it's wonderful. At the same time, i noticed a few corner-cases where the new pieces were duplicating the existing information or otherwise not helpful:

operator_question_mark.html762 KBDownload

more_repeats.html1 MBDownload

This doesn't look like a fundamental problem to me; it should be possible to improve upon these corner-cases by varying note messages; probably it also makes sense to skip some of them when they're clearly saying the same info 10 times in a row, but i'm not sure it's easy to decide where to apply that.

Because it might be a large amount of work, i'm thinking about committing this new feature off-by-default first (eg., -analyzer-config knowing-notes=[false|true]) and then doing follow-up commits (you already have quite a bit!) to make sure it's polished when we turn it on for everyone, WDYT?

include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h

169–173 ↗

(On Diff #189921)

Does this absolutely need to be a member variable? Maybe pass it down the stack, like tookTrue? I understand that there are already a lot of flags passed down, but global mutable state is still more dangerous and can easily get out of hand.

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

182–185

I don't see this triggered on tests. It looks to me that this function is for now only applied to DeclRefExprs that are always glvalues and therefore should never be evaluated to a nonloc value.

1949–1950

I advocate for more parentheses :)

[NoQ]

Instead of having those as events similar to "Assuming", we could turn the new "Knowing" pieces into floating pop-ups - imagine you hover the mouse over a condition foo() and it says "foo() is false". That is, instead of PathDiagnosticsEventPiece, a new kind of piece can be introduced that is shown in scan-build as a pop-up similar to macro pop-ups. Like this:

We already have infrastructure for hover pop-up hints in HTML reports - we use it to display macro expansions, so it could be something similar, just of a different color.

[Charusso]

Address comments:

• Removed member variable.
• Introducing PathDiagnosticPopUpPiece(D60670)

Extras:

• Removed generic known condition evaluation printing
• So that we could not hook integers, removed that early-return code as well.

[Charusso]

Thanks you @NoQ for the great idea!

Without the duplicated BugReporter.cpp reports it could be an on-by-default patch, see:

Before:

before.html1 MBDownload

After:

after.html1 MBDownload

It is not perfect, but I like that and I have already got ideas how to use these new pieces.

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

182–185

Good catch!

[NoQ]

Yay!! I'm happy with this change and redirected all my wrath on its dependencies.

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

if (B->isAdditiveOp() && B->getType()->isPointerType()) {
     } else if (B->getRHS()->getType()->isPointerType()) {
       return B->getRHS();
     }
   }
   return nullptr;
 }
 
 /// Given that expression S represents a pointer that would be dereferenced,
 /// try to find a sub-expression from which the pointer came from.
 /// This is used for tracking down origins of a null or undefined value:
 /// "this is null because that is null because that is null" etc.
 /// We wipe away field and element offsets because they merely add offsets.
 /// We also wipe away all casts except lvalue-to-rvalue casts, because the
 /// latter represent an actual pointer dereference; however, we remove
 /// the final lvalue-to-rvalue cast before returning from this function
 /// because it demonstrates more clearly from where the pointer rvalue was
 /// loaded. Examples:
 ///   x->y.z      ==>  x (lvalue)
 ///   foo()->y.z  ==>  foo() (rvalue)
 const Expr *bugreporter::getDerefExpr(const Stmt *S) {
   const auto *E = dyn_cast<Expr>(S);
   if (!E)
     return nullptr;
 
   while (true) {
     if (const auto *CE = dyn_cast<CastExpr>(E)) {
       if (CE->getCastKind() == CK_LValueToRValue) {
         // This cast represents the load we're looking for.
         break;
       }
       E = CE->getSubExpr();
     } else if (const auto *B = dyn_cast<BinaryOperator>(E)) {
       // Pointer arithmetic: '*(x + 2)' -> 'x') etc.
       if (const Expr *Inner = peelOffPointerArithmetic(B)) {
         E = Inner;
       } else {
         // Probably more arithmetic can be pattern-matched here,
         // but for now give up.
         break;
       }
     } else if (const auto *U = dyn_cast<UnaryOperator>(E)) {
       if (U->getOpcode() == UO_Deref || U->getOpcode() == UO_AddrOf ||
           (U->isIncrementDecrementOp() && U->getType()->isPointerType())) {
         // Operators '*' and '&' don't actually mean anything.
         // We look at casts instead.
         E = U->getSubExpr();
       } else {
         // Probably more arithmetic can be pattern-matched here,
         // but for now give up.
         break;
       }
     }
     // Pattern match for a few useful cases: a[0], p->f, *p etc.
     else if (const auto *ME = dyn_cast<MemberExpr>(E)) {
       E = ME->getBase();
     } else if (const auto *IvarRef = dyn_cast<ObjCIvarRefExpr>(E)) {
       E = IvarRef->getBase();
     } else if (const auto *AE = dyn_cast<ArraySubscriptExpr>(E)) {
       E = AE->getBase();
     } else if (const auto *PE = dyn_cast<ParenExpr>(E)) {
       E = PE->getSubExpr();
     } else if (const auto *EWC = dyn_cast<ExprWithCleanups>(E)) {
       E = EWC->getSubExpr();
     } else {
       // Other arbitrary stuff.
       break;
     }
   }
 
   // Special case: remove the final lvalue-to-rvalue cast, but do not recurse
   // deeper into the sub-expression. This way we return the lvalue from which
   // our pointer rvalue was loaded.
   if (const auto *CE = dyn_cast<ImplicitCastExpr>(E))
     if (CE->getCastKind() == CK_LValueToRValue)
       E = CE->getSubExpr();
 
   return E;
 }
 
 const Stmt *bugreporter::GetDenomExpr(const ExplodedNode *N) {
   const Stmt *S = N->getLocationAs<PreStmt>()->getStmt();
   if (const auto *BE = dyn_cast<BinaryOperator>(S))
     return BE->getRHS();
   return nullptr;
 }
 
 const Stmt *bugreporter::GetRetValExpr(const ExplodedNode *N) {
   const Stmt *S = N->getLocationAs<PostStmt>()->getStmt();
   if (const auto *RS = dyn_cast<ReturnStmt>(S))
     return RS->getRetValue();
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // Definitions for bug reporter visitors.
 //===----------------------------------------------------------------------===//
 
 std::shared_ptr<PathDiagnosticPiece>
 BugReporterVisitor::getEndPath(BugReporterContext &,
                                const ExplodedNode *, BugReport &) {
   return nullptr;
 }
 
 void
 BugReporterVisitor::finalizeVisitor(BugReporterContext &,
                                     const ExplodedNode *, BugReport &) {}
 
 std::shared_ptr<PathDiagnosticPiece> BugReporterVisitor::getDefaultEndPath(
     BugReporterContext &BRC, const ExplodedNode *EndPathNode, BugReport &BR) {
   PathDiagnosticLocation L =
     PathDiagnosticLocation::createEndOfPath(EndPathNode,BRC.getSourceManager());
 
   const auto &Ranges = BR.getRanges();
 
if (auto *ev = dyn_cast<PathDiagnosticEventPiece>(piece.get()))
       ev->setPrunable(true, /* override */ false);
   }
   return piece;
 }
 
 std::shared_ptr<PathDiagnosticPiece>
 ConditionBRVisitor::VisitNodeImpl(const ExplodedNode *N,
                                   BugReporterContext &BRC, BugReport &BR) {
   ProgramPoint progPoint = N->getLocation();
-  ProgramStateRef CurrentState = N->getState();
-  ProgramStateRef PrevState = N->getFirstPred()->getState();
-
-  // Compare the GDMs of the state, because that is where constraints
-  // are managed.  Note that ensure that we only look at nodes that
-  // were generated by the analyzer engine proper, not checkers.
-  if (CurrentState->getGDM().getRoot() ==
-      PrevState->getGDM().getRoot())
-    return nullptr;
 
   // If an assumption was made on a branch, it should be caught
   // here by looking at the state transition.
   if (Optional<BlockEdge> BE = progPoint.getAs<BlockEdge>()) {
     const CFGBlock *srcBlk = BE->getSrc();
     if (const Stmt *term = srcBlk->getTerminator())
       return VisitTerminator(term, N, srcBlk, BE->getDst(), BR, BRC);
     return nullptr;
   }
 
   if (Optional<PostStmt> PS = progPoint.getAs<PostStmt>()) {
     const std::pair<const ProgramPointTag *, const ProgramPointTag *> &tags =
         ExprEngine::geteagerlyAssumeBinOpBifurcationTags();
 
     const ProgramPointTag *tag = PS->getTag();
     if (tag == tags.first)
-      return VisitTrueTest(cast<Expr>(PS->getStmt()), true,
-                           BRC, BR, N);
+      return VisitTrueTest(cast<Expr>(PS->getStmt()), true, BRC, BR, N);
     if (tag == tags.second)
-      return VisitTrueTest(cast<Expr>(PS->getStmt()), false,
-                           BRC, BR, N);
+      return VisitTrueTest(cast<Expr>(PS->getStmt()), false, BRC, BR, N);
 
     return nullptr;
   }
 
   return nullptr;
 }
 
 std::shared_ptr<PathDiagnosticPiece> ConditionBRVisitor::VisitTerminator(
     const Stmt *Term, const ExplodedNode *N, const CFGBlock *srcBlk,
     const CFGBlock *dstBlk, BugReport &R, BugReporterContext &BRC) {
   const Expr *Cond = nullptr;
 
   // In the code below, Term is a CFG terminator and Cond is a branch condition
   // expression upon which the decision is made on this terminator.
   //
   // For example, in "if (x == 0)", the "if (x == 0)" statement is a terminator,
   // and "x == 0" is the respective condition.
   //
   // Another example: in "if (x && y)", we've got two terminators and two
   // conditions due to short-circuit nature of operator "&&":
   // 1. The "if (x && y)" statement is a terminator,
   //    and "y" is the respective condition.
   // 2. Also "x && ..." is another terminator,
   //    and "x" is its condition.
ConditionBRVisitor::VisitTrueTest(const Expr *Cond, bool tookTrue,
   // Condition too complex to explain? Just say something so that the user
   // knew we've made some path decision at this point.
   const LocationContext *LCtx = N->getLocationContext();
   PathDiagnosticLocation Loc(Cond, BRC.getSourceManager(), LCtx);
   if (!Loc.isValid() || !Loc.asLocation().isValid())
     return nullptr;
 
   return std::make_shared<PathDiagnosticEventPiece>(
       Loc, tookTrue ? GenericTrueMessage : GenericFalseMessage);
 }
 
 bool ConditionBRVisitor::patternMatch(const Expr *Ex,
                                       const Expr *ParentEx,
                                       raw_ostream &Out,
                                       BugReporterContext &BRC,
                                       BugReport &report,
                                       const ExplodedNode *N,
                                       Optional<bool> &prunable) {
   const Expr *OriginalExpr = Ex;
   Ex = Ex->IgnoreParenCasts();
ConditionBRVisitor::VisitTrueTest(const Expr *Cond, const BinaryOperator *BExpr,
   const LocationContext *LCtx = N->getLocationContext();
   PathDiagnosticLocation Loc(Cond, BRC.getSourceManager(), LCtx);
   auto event = std::make_shared<PathDiagnosticEventPiece>(Loc, Out.str());
   if (shouldPrune.hasValue())
     event->setPrunable(shouldPrune.getValue());
   return event;
 }
 
 std::shared_ptr<PathDiagnosticPiece> ConditionBRVisitor::VisitConditionVariable(
     StringRef LhsString, const Expr *CondVarExpr, const bool tookTrue,
     BugReporterContext &BRC, BugReport &report, const ExplodedNode *N) {
   // FIXME: If there's already a constraint tracker for this variable,
   // we shouldn't emit anything here (c.f. the double note in
   // test/Analysis/inlining/path-notes.c)
   SmallString<256> buf;
   llvm::raw_svector_ostream Out(buf);
   Out << "Assuming " << LhsString << " is ";
else {
         event->setPrunable(false);
     }
   }
   return std::move(event);
 }
 
 const char *const ConditionBRVisitor::GenericTrueMessage =
     "Assuming the condition is true";
 const char *const ConditionBRVisitor::GenericFalseMessage =
     "Assuming the condition is false";
 
 bool ConditionBRVisitor::isPieceMessageGeneric(
     const PathDiagnosticPiece *Piece) {
   return Piece->getString() == GenericTrueMessage ||
          Piece->getString() == GenericFalseMessage;
 }
 

test/Analysis/Inputs/expected-plists/NewDelete-path-notes.cpp.plist

<key>edges</key>
            <key>line</key><integer>9</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>11</integer>
+           <key>line</key><integer>9</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>9</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>9</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>9</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>9</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;p&apos; is non-null</string>
+     <key>message</key>
+     <string>Assuming &apos;p&apos; is non-null</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>9</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>9</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
+           <key>line</key><integer>12</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>11</integer>
+           <key>line</key><integer>12</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>11</integer>
+      <key>line</key><integer>12</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>11</integer>
+         <key>line</key><integer>12</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>11</integer>
+         <key>line</key><integer>12</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Memory is released</string>
      <key>message</key>
      <string>Memory is released</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>11</integer>
+           <key>line</key><integer>12</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>11</integer>
+           <key>line</key><integer>12</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>14</integer>
+           <key>line</key><integer>15</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>14</integer>
+           <key>line</key><integer>15</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>14</integer>
+      <key>line</key><integer>15</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>14</integer>
+         <key>line</key><integer>15</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>14</integer>
+         <key>line</key><integer>15</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Attempt to free released memory</string>
      <key>message</key>
      <string>Attempt to free released memory</string>
     </dict>
    </array>
    <key>description</key><string>Attempt to free released memory</string>
    <key>category</key><string>Memory error</string>
    <key>type</key><string>Double free</string>
    <key>check_name</key><string>cplusplus.NewDelete</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>bd8e324d09c70b9e2be6f824a4942e5a</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test</string>
-  <key>issue_hash_function_offset</key><string>8</string>
+  <key>issue_hash_function_offset</key><string>9</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>14</integer>
+   <key>line</key><integer>15</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
     <integer>6</integer>
     <integer>7</integer>
     <integer>9</integer>
-    <integer>11</integer>
-    <integer>14</integer>
+    <integer>12</integer>
+    <integer>15</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>25</integer>
+      <key>line</key><integer>26</integer>
       <key>col</key><integer>2</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>25</integer>
+         <key>line</key><integer>26</integer>
          <key>col</key><integer>2</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>25</integer>
+         <key>line</key><integer>26</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling &apos;Odd::kill&apos;</string>
      <key>message</key>
      <string>Calling &apos;Odd::kill&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>19</integer>
+      <key>line</key><integer>20</integer>
       <key>col</key><integer>2</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;test&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;test&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>19</integer>
+           <key>line</key><integer>20</integer>
            <key>col</key><integer>2</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>19</integer>
+           <key>line</key><integer>20</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>20</integer>
+           <key>line</key><integer>21</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>20</integer>
+           <key>line</key><integer>21</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>20</integer>
+      <key>line</key><integer>21</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>20</integer>
+         <key>line</key><integer>21</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>20</integer>
+         <key>line</key><integer>21</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Memory is released</string>
      <key>message</key>
      <string>Memory is released</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>25</integer>
+      <key>line</key><integer>26</integer>
       <key>col</key><integer>2</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>25</integer>
+         <key>line</key><integer>26</integer>
          <key>col</key><integer>2</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>25</integer>
+         <key>line</key><integer>26</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Returning; memory was released</string>
      <key>message</key>
      <string>Returning; memory was released</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>25</integer>
+           <key>line</key><integer>26</integer>
            <key>col</key><integer>2</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>25</integer>
+           <key>line</key><integer>26</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>27</integer>
+           <key>line</key><integer>28</integer>
            <key>col</key><integer>2</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>27</integer>
+           <key>line</key><integer>28</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>27</integer>
+      <key>line</key><integer>28</integer>
       <key>col</key><integer>2</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>27</integer>
+         <key>line</key><integer>28</integer>
          <key>col</key><integer>2</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>27</integer>
+         <key>line</key><integer>28</integer>
          <key>col</key><integer>11</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Attempt to free released memory</string>
      <key>message</key>
      <string>Attempt to free released memory</string>
     </dict>
    </array>
    <key>description</key><string>Attempt to free released memory</string>
    <key>category</key><string>Memory error</string>
    <key>type</key><string>Double free</string>
    <key>check_name</key><string>cplusplus.NewDelete</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>8bf1a5b9fdae9d86780aa6c4cdce2605</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test</string>
   <key>issue_hash_function_offset</key><string>3</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>27</integer>
+   <key>line</key><integer>28</integer>
    <key>col</key><integer>2</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>19</integer>
     <integer>20</integer>
-    <integer>24</integer>
+    <integer>21</integer>
     <integer>25</integer>
-    <integer>27</integer>
+    <integer>26</integer>
+    <integer>28</integer>
    </array>
   </dict>
   </dict>
  </array>
  <key>files</key>
  <array>
    <string>/clang/test/Analysis/NewDelete-path-notes.cpp</string>
  </array>
 </dict>
 </plist>

test/Analysis/Inputs/expected-plists/conditional-path-notes.c.plist

<array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;p&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;p&apos; is null</string>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>25</integer>
+      <key>col</key><integer>11</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>25</integer>
+         <key>col</key><integer>11</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>25</integer>
+         <key>col</key><integer>12</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;p&apos; is null</string>
+     <key>message</key>
+     <string>Assuming &apos;p&apos; is null</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>25</integer>
<array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>33</integer>
+           <key>line</key><integer>34</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>33</integer>
+           <key>line</key><integer>34</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>33</integer>
+           <key>line</key><integer>34</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>33</integer>
+           <key>line</key><integer>34</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>33</integer>
+      <key>line</key><integer>34</integer>
       <key>col</key><integer>11</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>33</integer>
+         <key>line</key><integer>34</integer>
          <key>col</key><integer>11</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>33</integer>
+         <key>line</key><integer>34</integer>
          <key>col</key><integer>11</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;p&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;p&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>33</integer>
+           <key>line</key><integer>34</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>33</integer>
+           <key>line</key><integer>34</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>33</integer>
+           <key>line</key><integer>34</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>33</integer>
+           <key>line</key><integer>34</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>33</integer>
+      <key>line</key><integer>34</integer>
       <key>col</key><integer>19</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>33</integer>
+         <key>line</key><integer>34</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>33</integer>
+         <key>line</key><integer>34</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
      <key>message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
     </dict>
    </array>
    <key>description</key><string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>b8e93b7355a6779a960f9a942fafac15</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testRHSProblem</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>33</integer>
+   <key>line</key><integer>34</integer>
    <key>col</key><integer>19</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>32</integer>
     <integer>33</integer>
+    <integer>34</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>41</integer>
+      <key>line</key><integer>42</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>41</integer>
+         <key>line</key><integer>42</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>41</integer>
+         <key>line</key><integer>42</integer>
          <key>col</key><integer>8</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>&apos;x&apos; initialized to a null pointer value</string>
      <key>message</key>
      <string>&apos;x&apos; initialized to a null pointer value</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>41</integer>
+           <key>line</key><integer>42</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>41</integer>
+           <key>line</key><integer>42</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>44</integer>
+           <key>line</key><integer>45</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>44</integer>
+           <key>line</key><integer>45</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>44</integer>
+           <key>line</key><integer>45</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>44</integer>
+           <key>line</key><integer>45</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>44</integer>
+           <key>line</key><integer>45</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>44</integer>
+           <key>line</key><integer>45</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>44</integer>
+      <key>line</key><integer>45</integer>
       <key>col</key><integer>6</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>44</integer>
+         <key>line</key><integer>45</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>44</integer>
+         <key>line</key><integer>45</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Dereference of null pointer (loaded from variable &apos;x&apos;)</string>
      <key>message</key>
      <string>Dereference of null pointer (loaded from variable &apos;x&apos;)</string>
     </dict>
    </array>
    <key>description</key><string>Dereference of null pointer (loaded from variable &apos;x&apos;)</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>a944281d096940ca43ec995649b48b5f</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testBinaryCondOp</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>44</integer>
+   <key>line</key><integer>45</integer>
    <key>col</key><integer>6</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>40</integer>
     <integer>41</integer>
-    <integer>44</integer>
+    <integer>42</integer>
+    <integer>45</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>49</integer>
+           <key>line</key><integer>50</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>49</integer>
+           <key>line</key><integer>50</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>49</integer>
+           <key>line</key><integer>50</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>49</integer>
+           <key>line</key><integer>50</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>49</integer>
+      <key>line</key><integer>50</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>49</integer>
+         <key>line</key><integer>50</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>49</integer>
+         <key>line</key><integer>50</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;p&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;p&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>49</integer>
+           <key>line</key><integer>50</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>49</integer>
+           <key>line</key><integer>50</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>53</integer>
+           <key>line</key><integer>54</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>53</integer>
+           <key>line</key><integer>54</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>53</integer>
+           <key>line</key><integer>54</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>53</integer>
+           <key>line</key><integer>54</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>53</integer>
+           <key>line</key><integer>54</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>53</integer>
+           <key>line</key><integer>54</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>53</integer>
+      <key>line</key><integer>54</integer>
       <key>col</key><integer>11</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>53</integer>
+         <key>line</key><integer>54</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>53</integer>
+         <key>line</key><integer>54</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
      <key>message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
     </dict>
    </array>
    <key>description</key><string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>4db164bbf5cea42d75c5e838be1eef6f</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testBinaryLHSProblem</string>
   <key>issue_hash_function_offset</key><string>5</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>53</integer>
+   <key>line</key><integer>54</integer>
    <key>col</key><integer>11</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>48</integer>
     <integer>49</integer>
-    <integer>53</integer>
+    <integer>50</integer>
+    <integer>54</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>60</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>60</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>60</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>60</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>59</integer>
+      <key>line</key><integer>60</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>59</integer>
+         <key>line</key><integer>60</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>59</integer>
+         <key>line</key><integer>60</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;a&apos; is not equal to 0</string>
      <key>message</key>
      <string>Assuming &apos;a&apos; is not equal to 0</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>60</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>60</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>62</integer>
+           <key>line</key><integer>63</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>62</integer>
+           <key>line</key><integer>63</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>62</integer>
+           <key>line</key><integer>63</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>62</integer>
+           <key>line</key><integer>63</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>62</integer>
+           <key>line</key><integer>63</integer>
            <key>col</key><integer>24</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>62</integer>
+           <key>line</key><integer>63</integer>
            <key>col</key><integer>24</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>62</integer>
+      <key>line</key><integer>63</integer>
       <key>col</key><integer>24</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>62</integer>
+         <key>line</key><integer>63</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>62</integer>
+         <key>line</key><integer>63</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Dereference of null pointer</string>
      <key>message</key>
      <string>Dereference of null pointer</string>
     </dict>
    </array>
    <key>description</key><string>Dereference of null pointer</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>778d56ad485369222613ac2c03b97700</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testDiagnosableBranch</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>62</integer>
+   <key>line</key><integer>63</integer>
    <key>col</key><integer>24</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>58</integer>
     <integer>59</integer>
-    <integer>62</integer>
+    <integer>60</integer>
+    <integer>63</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>68</integer>
+           <key>line</key><integer>69</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>68</integer>
+           <key>line</key><integer>69</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>68</integer>
+           <key>line</key><integer>69</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>68</integer>
+           <key>line</key><integer>69</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>68</integer>
+      <key>line</key><integer>69</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>68</integer>
+         <key>line</key><integer>69</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>68</integer>
+         <key>line</key><integer>69</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;a&apos; is not equal to 0</string>
      <key>message</key>
      <string>Assuming &apos;a&apos; is not equal to 0</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>68</integer>
+           <key>line</key><integer>69</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>68</integer>
+           <key>line</key><integer>69</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>68</integer>
+           <key>line</key><integer>69</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>68</integer>
+           <key>line</key><integer>69</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>68</integer>
+      <key>line</key><integer>69</integer>
       <key>col</key><integer>12</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>68</integer>
+         <key>line</key><integer>69</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>68</integer>
+         <key>line</key><integer>69</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;b&apos; is not equal to 0</string>
      <key>message</key>
      <string>Assuming &apos;b&apos; is not equal to 0</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>68</integer>
+           <key>line</key><integer>69</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>68</integer>
+           <key>line</key><integer>69</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>73</integer>
+           <key>line</key><integer>74</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>73</integer>
+           <key>line</key><integer>74</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>73</integer>
+           <key>line</key><integer>74</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>73</integer>
+           <key>line</key><integer>74</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>73</integer>
+           <key>line</key><integer>74</integer>
            <key>col</key><integer>24</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>73</integer>
+           <key>line</key><integer>74</integer>
            <key>col</key><integer>24</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>73</integer>
+      <key>line</key><integer>74</integer>
       <key>col</key><integer>24</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>73</integer>
+         <key>line</key><integer>74</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>73</integer>
+         <key>line</key><integer>74</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Dereference of null pointer</string>
      <key>message</key>
      <string>Dereference of null pointer</string>
     </dict>
    </array>
    <key>description</key><string>Dereference of null pointer</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>a2b345c9681d9dd3aa15d12810759cb9</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testDiagnosableBranchLogical</string>
   <key>issue_hash_function_offset</key><string>6</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>73</integer>
+   <key>line</key><integer>74</integer>
    <key>col</key><integer>24</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>67</integer>
     <integer>68</integer>
-    <integer>73</integer>
+    <integer>69</integer>
+    <integer>74</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>79</integer>
+           <key>line</key><integer>80</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>79</integer>
+           <key>line</key><integer>80</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>79</integer>
+           <key>line</key><integer>80</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>79</integer>
+           <key>line</key><integer>80</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>79</integer>
+      <key>line</key><integer>80</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>79</integer>
+         <key>line</key><integer>80</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>79</integer>
+         <key>line</key><integer>80</integer>
          <key>col</key><integer>11</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming the condition is true</string>
      <key>message</key>
      <string>Assuming the condition is true</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>79</integer>
+           <key>line</key><integer>80</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>79</integer>
+           <key>line</key><integer>80</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>82</integer>
+           <key>line</key><integer>83</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>82</integer>
+           <key>line</key><integer>83</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>82</integer>
+           <key>line</key><integer>83</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>82</integer>
+           <key>line</key><integer>83</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>82</integer>
+           <key>line</key><integer>83</integer>
            <key>col</key><integer>24</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>82</integer>
+           <key>line</key><integer>83</integer>
            <key>col</key><integer>24</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>82</integer>
+      <key>line</key><integer>83</integer>
       <key>col</key><integer>24</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>82</integer>
+         <key>line</key><integer>83</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>82</integer>
+         <key>line</key><integer>83</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Dereference of null pointer</string>
      <key>message</key>
      <string>Dereference of null pointer</string>
     </dict>
    </array>
    <key>description</key><string>Dereference of null pointer</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>f56671e5f67c73abef619b56f7c29fa4</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testNonDiagnosableBranchArithmetic</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>82</integer>
+   <key>line</key><integer>83</integer>
    <key>col</key><integer>24</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>78</integer>
     <integer>79</integer>
-    <integer>82</integer>
+    <integer>80</integer>
+    <integer>83</integer>
    </array>
   </dict>
   </dict>
  </array>
  <key>files</key>
  <array>
    <string>/clang/test/Analysis/conditional-path-notes.c</string>
  </array>
 </dict>
-</plist>
+</plist>
 No newline at end of file

test/Analysis/Inputs/expected-plists/cxx-for-range.cpp.plist

<key>edges</key>
            <key>line</key><integer>11</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>11</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>11</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>11</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>11</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>11</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;y&apos; is not equal to 2</string>
+     <key>message</key>
+     <string>Assuming &apos;y&apos; is not equal to 2</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>11</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>11</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>13</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>13</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
           </dict>
           <dict>
            <key>line</key><integer>11</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
           <array>
            <dict>
+           <key>line</key><integer>11</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>11</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>11</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>11</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>11</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;y&apos; is equal to 2</string>
+     <key>message</key>
+     <string>Assuming &apos;y&apos; is equal to 2</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>11</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>11</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>12</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>12</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
           </dict>
           <dict>
            <key>line</key><integer>32</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
           <array>
            <dict>
+           <key>line</key><integer>32</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>32</integer>
+           <key>col</key><integer>10</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>32</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>32</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>32</integer>
+         <key>col</key><integer>10</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>1</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;fail&apos; is not equal to 0</string>
+     <key>message</key>
+     <string>Assuming &apos;fail&apos; is not equal to 0</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>32</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>32</integer>
+           <key>col</key><integer>10</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>33</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>33</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>

test/Analysis/Inputs/expected-plists/edges-new.mm.plist

<array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;p&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;p&apos; is null</string>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>70</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>70</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>70</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;p&apos; is null</string>
+     <key>message</key>
+     <string>Assuming &apos;p&apos; is null</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>70</integer>
<key>edges</key>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>146</integer>
+      <key>col</key><integer>8</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>146</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>146</integer>
+         <key>col</key><integer>13</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;i&apos; is not equal to 1</string>
+     <key>message</key>
+     <string>Assuming &apos;i&apos; is not equal to 1</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>146</integer>
<key>edges</key>
            <key>line</key><integer>146</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>146</integer>
+           <key>col</key><integer>8</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>146</integer>
+           <key>col</key><integer>8</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>146</integer>
+      <key>col</key><integer>8</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>146</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>146</integer>
+         <key>col</key><integer>13</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;i&apos; is equal to 1</string>
+     <key>message</key>
+     <string>Assuming &apos;i&apos; is equal to 1</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>146</integer>
+           <key>col</key><integer>8</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>146</integer>
+           <key>col</key><integer>8</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>147</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>147</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>line</key><integer>178</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>178</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>178</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>178</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>178</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>178</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;i&apos; is equal to 0</string>
+     <key>message</key>
+     <string>Assuming &apos;i&apos; is equal to 0</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>178</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>178</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>179</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>179</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>line</key><integer>178</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>178</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>178</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>178</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>178</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>178</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;i&apos; is not equal to 0</string>
+     <key>message</key>
+     <string>Assuming &apos;i&apos; is not equal to 0</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>178</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>178</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>181</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>181</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>line</key><integer>181</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>181</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>181</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>181</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>181</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>181</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;i&apos; is equal to 1</string>
+     <key>message</key>
+     <string>Assuming &apos;i&apos; is equal to 1</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>181</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>181</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>183</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>183</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>240</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>240</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>240</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is true</string>
+     <key>message</key>
+     <string>Assuming the condition is true</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>240</integer>
<key>edges</key>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>240</integer>
+      <key>col</key><integer>12</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>240</integer>
+         <key>col</key><integer>12</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>240</integer>
+         <key>col</key><integer>12</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is true</string>
+     <key>message</key>
+     <string>Assuming the condition is true</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>240</integer>
<key>edges</key>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>247</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>247</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>247</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is false</string>
+     <key>message</key>
+     <string>Assuming the condition is false</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>247</integer>
<key>edges</key>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>247</integer>
+      <key>col</key><integer>12</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>247</integer>
+         <key>col</key><integer>12</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>247</integer>
+         <key>col</key><integer>12</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is true</string>
+     <key>message</key>
+     <string>Assuming the condition is true</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>247</integer>
<key>edges</key>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>255</integer>
+      <key>col</key><integer>12</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>255</integer>
+         <key>col</key><integer>12</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>255</integer>
+         <key>col</key><integer>12</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is false</string>
+     <key>message</key>
+     <string>Assuming the condition is false</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>255</integer>
<key>edges</key>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>263</integer>
+      <key>col</key><integer>8</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>263</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>263</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is false</string>
+     <key>message</key>
+     <string>Assuming the condition is false</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>263</integer>
<key>edges</key>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
            <key>line</key><integer>263</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>263</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>263</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>263</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>263</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is false</string>
+     <key>message</key>
+     <string>Assuming the condition is false</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>263</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>263</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
+           <key>line</key><integer>263</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>263</integer>
            <key>col</key><integer>22</integer>
            <key>file</key><integer>0</integer>
           </dict>
<key>edges</key>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>263</integer>
+      <key>col</key><integer>8</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>263</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>263</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is false</string>
+     <key>message</key>
+     <string>Assuming the condition is false</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>263</integer>
<key>edges</key>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
            <key>line</key><integer>263</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>263</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>263</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>263</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>263</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is false</string>
+     <key>message</key>
+     <string>Assuming the condition is false</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>263</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>263</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
+           <key>line</key><integer>263</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>263</integer>
            <key>col</key><integer>22</integer>
            <key>file</key><integer>0</integer>
           </dict>
<key>edges</key>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>267</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>267</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>267</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is false</string>
+     <key>message</key>
+     <string>Assuming the condition is false</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>267</integer>
<key>edges</key>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>267</integer>
+      <key>col</key><integer>13</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>267</integer>
+         <key>col</key><integer>13</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>267</integer>
+         <key>col</key><integer>13</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is false</string>
+     <key>message</key>
+     <string>Assuming the condition is false</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>267</integer>
<key>edges</key>
            <key>col</key><integer>18</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>267</integer>
+      <key>col</key><integer>18</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>267</integer>
+         <key>col</key><integer>18</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>267</integer>
+         <key>col</key><integer>22</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;coin&apos; is 0</string>
+     <key>message</key>
+     <string>Assuming &apos;coin&apos; is 0</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>267</integer>
<key>edges</key>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>276</integer>
+      <key>col</key><integer>8</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>276</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>276</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is false</string>
+     <key>message</key>
+     <string>Assuming the condition is false</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>276</integer>
<key>edges</key>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>276</integer>
+      <key>col</key><integer>14</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>276</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>276</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is true</string>
+     <key>message</key>
+     <string>Assuming the condition is true</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>276</integer>
<key>edges</key>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
            <key>line</key><integer>276</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>276</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>276</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>276</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>276</integer>
+         <key>col</key><integer>21</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is false</string>
+     <key>message</key>
+     <string>Assuming the condition is false</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>276</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>276</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
+           <key>line</key><integer>276</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>276</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>276</integer>
+      <key>col</key><integer>31</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>276</integer>
+         <key>col</key><integer>31</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>276</integer>
+         <key>col</key><integer>31</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is false</string>
+     <key>message</key>
+     <string>Assuming the condition is false</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>276</integer>
<key>edges</key>
            <key>col</key><integer>36</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
            <key>line</key><integer>276</integer>
+           <key>col</key><integer>30</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>276</integer>
+           <key>col</key><integer>30</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>276</integer>
+      <key>col</key><integer>30</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>276</integer>
+         <key>col</key><integer>30</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>276</integer>
+         <key>col</key><integer>37</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is true</string>
+     <key>message</key>
+     <string>Assuming the condition is true</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>276</integer>
+           <key>col</key><integer>30</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>276</integer>
+           <key>col</key><integer>30</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
+           <key>line</key><integer>276</integer>
            <key>col</key><integer>46</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>276</integer>
            <key>col</key><integer>46</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>276</integer>
+      <key>col</key><integer>46</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>276</integer>
+         <key>col</key><integer>46</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>276</integer>
+         <key>col</key><integer>46</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is true</string>
+     <key>message</key>
+     <string>Assuming the condition is true</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>276</integer>
<key>edges</key>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>285</integer>
+      <key>col</key><integer>12</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>285</integer>
+         <key>col</key><integer>12</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>285</integer>
+         <key>col</key><integer>12</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;z&apos; is 0</string>
+     <key>message</key>
+     <string>Assuming &apos;z&apos; is 0</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>285</integer>
<key>edges</key>
            <key>line</key><integer>294</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>294</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>294</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>294</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>294</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>294</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;y&apos; is null</string>
+     <key>message</key>
+     <string>Assuming &apos;y&apos; is null</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>294</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>294</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>297</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>297</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>line</key><integer>457</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>457</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+     <key>message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>line</key><integer>457</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>457</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;first&apos; is 0</string>
+     <key>message</key>
+     <string>Assuming &apos;first&apos; is 0</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>458</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>458</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>line</key><integer>457</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>457</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+     <key>message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>line</key><integer>457</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>457</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+     <key>message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>line</key><integer>457</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>457</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+     <key>message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>line</key><integer>457</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>457</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+     <key>message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>line</key><integer>457</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>457</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+     <key>message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>line</key><integer>457</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>457</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>457</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+     <key>message</key>
+     <string>Assuming &apos;first&apos; is not equal to 0</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>457</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>459</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
<array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reallocation failed</string>
      <key>message</key>
      <string>Reallocation failed</string>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>532</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>532</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>532</integer>
+         <key>col</key><integer>10</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;tmp&apos; is null</string>
+     <key>message</key>
+     <string>Assuming &apos;tmp&apos; is null</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>532</integer>
<key>edges</key>
            <key>line</key><integer>587</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>587</integer>
+           <key>col</key><integer>11</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>587</integer>
+           <key>col</key><integer>11</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>587</integer>
+      <key>col</key><integer>11</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>587</integer>
+         <key>col</key><integer>11</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>587</integer>
+         <key>col</key><integer>16</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is true</string>
+     <key>message</key>
+     <string>Assuming the condition is true</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>587</integer>
+           <key>col</key><integer>11</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>587</integer>
+           <key>col</key><integer>11</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>588</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>588</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>

   </dict>
   </dict>
  </array>
  <key>files</key>
  <array>
    <string>/clang/test/Analysis/edges-new.mm</string>
  </array>
 </dict>
-</plist>
+</plist>
 No newline at end of file

test/Analysis/Inputs/expected-plists/inline-plist.c.plist

<key>edges</key>
            <key>line</key><integer>45</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>47</integer>
+           <key>line</key><integer>45</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>45</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>45</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>45</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>45</integer>
+         <key>col</key><integer>12</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;p&apos; is equal to null</string>
+     <key>message</key>
+     <string>Assuming &apos;p&apos; is equal to null</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>45</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>45</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
+           <key>line</key><integer>48</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>47</integer>
+           <key>line</key><integer>48</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>47</integer>
+      <key>line</key><integer>48</integer>
       <key>col</key><integer>18</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>47</integer>
+         <key>line</key><integer>48</integer>
          <key>col</key><integer>18</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>47</integer>
+         <key>line</key><integer>48</integer>
          <key>col</key><integer>18</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Passing null pointer value via 1st parameter &apos;p&apos;</string>
      <key>message</key>
      <string>Passing null pointer value via 1st parameter &apos;p&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>47</integer>
+      <key>line</key><integer>48</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>47</integer>
+         <key>line</key><integer>48</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>47</integer>
+         <key>line</key><integer>48</integer>
          <key>col</key><integer>19</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling &apos;triggers_bug&apos;</string>
<array>
   <dict>
    <key>0</key>
    <array>
     <integer>32</integer>
     <integer>33</integer>
     <integer>38</integer>
     <integer>39</integer>
     <integer>45</integer>
-    <integer>47</integer>
+    <integer>48</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>58</integer>
+      <key>line</key><integer>59</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>58</integer>
+         <key>line</key><integer>59</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>58</integer>
+         <key>line</key><integer>59</integer>
          <key>col</key><integer>8</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>&apos;p&apos; initialized to a null pointer value</string>
      <key>message</key>
      <string>&apos;p&apos; initialized to a null pointer value</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>58</integer>
+           <key>line</key><integer>59</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>58</integer>
+           <key>line</key><integer>59</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>60</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>60</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>59</integer>
+      <key>line</key><integer>60</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>59</integer>
+         <key>line</key><integer>60</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>61</integer>
+         <key>line</key><integer>62</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling anonymous block</string>
      <key>message</key>
      <string>Calling anonymous block</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>59</integer>
+      <key>line</key><integer>60</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;test_block__capture_null&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;test_block__capture_null&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>60</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>60</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>60</integer>
+           <key>line</key><integer>61</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>60</integer>
+           <key>line</key><integer>61</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>60</integer>
+           <key>line</key><integer>61</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>60</integer>
+           <key>line</key><integer>61</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>60</integer>
+           <key>line</key><integer>61</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>60</integer>
+           <key>line</key><integer>61</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>60</integer>
+      <key>line</key><integer>61</integer>
       <key>col</key><integer>8</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>60</integer>
+         <key>line</key><integer>61</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>60</integer>
+         <key>line</key><integer>61</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
      <key>message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
     </dict>
    </array>
    <key>description</key><string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>a2e7504f29818834127c44ba841f4da8</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>60</integer>
+   <key>line</key><integer>61</integer>
    <key>col</key><integer>8</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>57</integer>
     <integer>58</integer>
     <integer>59</integer>
     <integer>60</integer>
+    <integer>61</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>66</integer>
+           <key>line</key><integer>67</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>66</integer>
+           <key>line</key><integer>67</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>66</integer>
+           <key>line</key><integer>67</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>66</integer>
+           <key>line</key><integer>67</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>66</integer>
+      <key>line</key><integer>67</integer>
       <key>col</key><integer>12</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>66</integer>
+         <key>line</key><integer>67</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>69</integer>
+         <key>line</key><integer>70</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling anonymous block</string>
      <key>message</key>
      <string>Calling anonymous block</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>66</integer>
+      <key>line</key><integer>67</integer>
       <key>col</key><integer>12</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;test_block_ret&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;test_block_ret&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>66</integer>
+           <key>line</key><integer>67</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>66</integer>
+           <key>line</key><integer>67</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>67</integer>
+           <key>line</key><integer>68</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>67</integer>
+           <key>line</key><integer>68</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>67</integer>
+      <key>line</key><integer>68</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>67</integer>
+         <key>line</key><integer>68</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>67</integer>
+         <key>line</key><integer>68</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>&apos;q&apos; initialized to a null pointer value</string>
      <key>message</key>
      <string>&apos;q&apos; initialized to a null pointer value</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>67</integer>
+           <key>line</key><integer>68</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>67</integer>
+           <key>line</key><integer>68</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>68</integer>
+           <key>line</key><integer>69</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>68</integer>
+           <key>line</key><integer>69</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>68</integer>
+      <key>line</key><integer>69</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>68</integer>
+         <key>line</key><integer>69</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>68</integer>
+         <key>line</key><integer>69</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Returning null pointer (loaded from &apos;q&apos;)</string>
      <key>message</key>
      <string>Returning null pointer (loaded from &apos;q&apos;)</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>66</integer>
+      <key>line</key><integer>67</integer>
       <key>col</key><integer>12</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>66</integer>
+         <key>line</key><integer>67</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>69</integer>
+         <key>line</key><integer>70</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Returning to caller</string>
      <key>message</key>
      <string>Returning to caller</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>66</integer>
+           <key>line</key><integer>67</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>66</integer>
+           <key>line</key><integer>67</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>66</integer>
+           <key>line</key><integer>67</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>66</integer>
+           <key>line</key><integer>67</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>66</integer>
+      <key>line</key><integer>67</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>66</integer>
+         <key>line</key><integer>67</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>66</integer>
+         <key>line</key><integer>67</integer>
          <key>col</key><integer>8</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>&apos;p&apos; initialized to a null pointer value</string>
      <key>message</key>
      <string>&apos;p&apos; initialized to a null pointer value</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>66</integer>
+           <key>line</key><integer>67</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>66</integer>
+           <key>line</key><integer>67</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>70</integer>
+           <key>line</key><integer>71</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>70</integer>
+           <key>line</key><integer>71</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>70</integer>
+           <key>line</key><integer>71</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>70</integer>
+           <key>line</key><integer>71</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>70</integer>
+           <key>line</key><integer>71</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>70</integer>
+           <key>line</key><integer>71</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>70</integer>
+      <key>line</key><integer>71</integer>
       <key>col</key><integer>6</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>70</integer>
+         <key>line</key><integer>71</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>70</integer>
+         <key>line</key><integer>71</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
      <key>message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
     </dict>
    </array>
    <key>description</key><string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>931be9c3a45b61c0a9c99b4772bd6fca</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_block_ret</string>
   <key>issue_hash_function_offset</key><string>5</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>70</integer>
+   <key>line</key><integer>71</integer>
    <key>col</key><integer>6</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>65</integer>
     <integer>66</integer>
     <integer>67</integer>
     <integer>68</integer>
-    <integer>70</integer>
+    <integer>69</integer>
+    <integer>71</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>74</integer>
+           <key>line</key><integer>75</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>74</integer>
+           <key>line</key><integer>75</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>75</integer>
+           <key>line</key><integer>76</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>75</integer>
+           <key>line</key><integer>76</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>75</integer>
+      <key>line</key><integer>76</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>75</integer>
+         <key>line</key><integer>76</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>77</integer>
+         <key>line</key><integer>78</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling anonymous block</string>
      <key>message</key>
      <string>Calling anonymous block</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>75</integer>
+      <key>line</key><integer>76</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;test_block_blockvar&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;test_block_blockvar&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>75</integer>
+           <key>line</key><integer>76</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>75</integer>
+           <key>line</key><integer>76</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>76</integer>
+           <key>line</key><integer>77</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>76</integer>
+           <key>line</key><integer>77</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>76</integer>
+      <key>line</key><integer>77</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>76</integer>
+         <key>line</key><integer>77</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>76</integer>
+         <key>line</key><integer>77</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Null pointer value stored to &apos;p&apos;</string>
      <key>message</key>
      <string>Null pointer value stored to &apos;p&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>75</integer>
+      <key>line</key><integer>76</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>75</integer>
+         <key>line</key><integer>76</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>77</integer>
+         <key>line</key><integer>78</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Returning to caller</string>
      <key>message</key>
      <string>Returning to caller</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>75</integer>
+           <key>line</key><integer>76</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>75</integer>
+           <key>line</key><integer>76</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>78</integer>
+           <key>line</key><integer>79</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>78</integer>
+           <key>line</key><integer>79</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>78</integer>
+           <key>line</key><integer>79</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>78</integer>
+           <key>line</key><integer>79</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>78</integer>
+           <key>line</key><integer>79</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>78</integer>
+           <key>line</key><integer>79</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>78</integer>
+      <key>line</key><integer>79</integer>
       <key>col</key><integer>6</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>78</integer>
+         <key>line</key><integer>79</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>78</integer>
+         <key>line</key><integer>79</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
      <key>message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
     </dict>
    </array>
    <key>description</key><string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>524a8647c40f017409d858ff70900c1a</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_block_blockvar</string>
   <key>issue_hash_function_offset</key><string>5</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>78</integer>
+   <key>line</key><integer>79</integer>
    <key>col</key><integer>6</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>73</integer>
     <integer>74</integer>
     <integer>75</integer>
     <integer>76</integer>
-    <integer>78</integer>
+    <integer>77</integer>
+    <integer>79</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>82</integer>
+           <key>line</key><integer>83</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>82</integer>
+           <key>line</key><integer>83</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>83</integer>
+           <key>line</key><integer>84</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>83</integer>
+           <key>line</key><integer>84</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>83</integer>
+      <key>line</key><integer>84</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>83</integer>
+         <key>line</key><integer>84</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>85</integer>
+         <key>line</key><integer>86</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling anonymous block</string>
      <key>message</key>
      <string>Calling anonymous block</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>83</integer>
+      <key>line</key><integer>84</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;test_block_arg&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;test_block_arg&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>83</integer>
+           <key>line</key><integer>84</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>83</integer>
+           <key>line</key><integer>84</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>84</integer>
+           <key>line</key><integer>85</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>84</integer>
+           <key>line</key><integer>85</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>84</integer>
+      <key>line</key><integer>85</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>84</integer>
+         <key>line</key><integer>85</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>84</integer>
+         <key>line</key><integer>85</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Null pointer value stored to &apos;p&apos;</string>
      <key>message</key>
      <string>Null pointer value stored to &apos;p&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>83</integer>
+      <key>line</key><integer>84</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>83</integer>
+         <key>line</key><integer>84</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>85</integer>
+         <key>line</key><integer>86</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Returning to caller</string>
      <key>message</key>
      <string>Returning to caller</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>83</integer>
+           <key>line</key><integer>84</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>83</integer>
+           <key>line</key><integer>84</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>86</integer>
+           <key>line</key><integer>87</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>86</integer>
+           <key>line</key><integer>87</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>86</integer>
+           <key>line</key><integer>87</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>86</integer>
+           <key>line</key><integer>87</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>86</integer>
+           <key>line</key><integer>87</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>86</integer>
+           <key>line</key><integer>87</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>86</integer>
+      <key>line</key><integer>87</integer>
       <key>col</key><integer>6</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>86</integer>
+         <key>line</key><integer>87</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>86</integer>
+         <key>line</key><integer>87</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
      <key>message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
     </dict>
    </array>
    <key>description</key><string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>0efdf891fbddf2932f9d434968b94164</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_block_arg</string>
   <key>issue_hash_function_offset</key><string>5</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>86</integer>
+   <key>line</key><integer>87</integer>
    <key>col</key><integer>6</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>81</integer>
     <integer>82</integer>
     <integer>83</integer>
     <integer>84</integer>
     <integer>85</integer>
     <integer>86</integer>
+    <integer>87</integer>
    </array>
   </dict>
   </dict>
  </array>
  <key>files</key>
  <array>
    <string>/clang/test/Analysis/inline-plist.c</string>
  </array>
 </dict>
 </plist>

test/Analysis/Inputs/expected-plists/method-call-path-notes.cpp.plist

<array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;p&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;p&apos; is null</string>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>29</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>29</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>29</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;p&apos; is null</string>
+     <key>message</key>
+     <string>Assuming &apos;p&apos; is null</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>29</integer>
<array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;p&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;p&apos; is null</string>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>41</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>41</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>41</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;p&apos; is null</string>
+     <key>message</key>
+     <string>Assuming &apos;p&apos; is null</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>41</integer>
<array>
   </dict>
   </dict>
  </array>
  <key>files</key>
  <array>
    <string>/clang/test/Analysis/method-call-path-notes.cpp</string>
  </array>
 </dict>
-</plist>
+</plist>
 No newline at end of file

test/Analysis/Inputs/expected-plists/model-file.cpp.plist

<key>edges</key>
            <key>line</key><integer>25</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>25</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>25</integer>
+           <key>col</key><integer>13</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>25</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>25</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>25</integer>
+         <key>col</key><integer>16</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is false</string>
+     <key>message</key>
+     <string>Assuming the condition is false</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>25</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>25</integer>
+           <key>col</key><integer>13</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>31</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>31</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>

test/Analysis/Inputs/expected-plists/plist-macros.cpp.plist

<array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;p&apos; is equal to null</string>
      <key>message</key>
      <string>Assuming &apos;p&apos; is equal to null</string>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>45</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>45</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>45</integer>
+         <key>col</key><integer>21</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;p&apos; is equal to null</string>
+     <key>message</key>
+     <string>Assuming &apos;p&apos; is equal to null</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>45</integer>
<array>
          <key>line</key><integer>69</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
+     <string>Assuming &apos;p&apos; is null</string>
+     <key>message</key>
+     <string>Assuming &apos;p&apos; is null</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>69</integer>
+      <key>col</key><integer>3</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>69</integer>
+         <key>col</key><integer>3</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>69</integer>
+         <key>col</key><integer>16</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
      <string>Assuming &apos;y&apos; is 0</string>
      <key>message</key>
      <string>Assuming &apos;y&apos; is 0</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>

   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>83</integer>
+      <key>line</key><integer>87</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>83</integer>
+         <key>line</key><integer>87</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>83</integer>
+         <key>line</key><integer>87</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
-     <string>Passing null pointer value via 1st parameter &apos;a&apos;</string>
+     <string>Passing value via 1st parameter &apos;a&apos;</string>
      <key>message</key>
-     <string>Passing null pointer value via 1st parameter &apos;a&apos;</string>
+     <string>Passing value via 1st parameter &apos;a&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>83</integer>
+      <key>line</key><integer>87</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>83</integer>
+         <key>line</key><integer>87</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>83</integer>
+         <key>line</key><integer>87</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling &apos;null_deref&apos;</string>
      <key>message</key>
      <string>Calling &apos;null_deref&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
       <key>line</key><integer>76</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
-     <string>Entered call from &apos;test1&apos;</string>
+     <string>Entered call from &apos;test2&apos;</string>
      <key>message</key>
-     <string>Entered call from &apos;test1&apos;</string>
+     <string>Entered call from &apos;test2&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
<key>edges</key>
            <key>line</key><integer>77</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>77</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>77</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>77</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>77</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>77</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>1</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;a&apos; is null</string>
+     <key>message</key>
+     <string>Assuming &apos;a&apos; is null</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>77</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>77</integer>
+           <key>col</key><integer>7</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>79</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>79</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>

   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
     <integer>76</integer>
     <integer>77</integer>
     <integer>79</integer>
-    <integer>82</integer>
-    <integer>83</integer>
+    <integer>86</integer>
+    <integer>87</integer>
    </array>
   </dict>
   </dict>
  </array>
  <key>files</key>
  <array>
    <string>/clang/test/Analysis/plist-macros.cpp</string>
  </array>
 </dict>
-</plist>
+</plist>
 No newline at end of file

test/Analysis/Inputs/expected-plists/plist-output-alternate.m.plist

<array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;p&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;p&apos; is null</string>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>23</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>23</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>23</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;p&apos; is null</string>
+     <key>message</key>
+     <string>Assuming &apos;p&apos; is null</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>23</integer>

   </dict>
   </dict>
  </array>
  <key>files</key>
  <array>
    <string>/clang/test/Analysis/plist-output-alternate.m</string>
  </array>
 </dict>
-</plist>
+</plist>
 No newline at end of file

test/Analysis/Inputs/expected-plists/plist-output.m.plist

<key>edges</key>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>96</integer>
+      <key>col</key><integer>8</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>96</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>96</integer>
+         <key>col</key><integer>13</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;i&apos; is not equal to 1</string>
+     <key>message</key>
+     <string>Assuming &apos;i&apos; is not equal to 1</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>96</integer>
<key>edges</key>
            <key>line</key><integer>96</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>96</integer>
+           <key>col</key><integer>8</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>96</integer>
+           <key>col</key><integer>8</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>96</integer>
+      <key>col</key><integer>8</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>96</integer>
+         <key>col</key><integer>8</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>96</integer>
+         <key>col</key><integer>13</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;i&apos; is equal to 1</string>
+     <key>message</key>
+     <string>Assuming &apos;i&apos; is equal to 1</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>96</integer>
+           <key>col</key><integer>8</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>96</integer>
+           <key>col</key><integer>8</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>97</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>97</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>127</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>127</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>127</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;i&apos; is not equal to 1</string>
+     <key>message</key>
+     <string>Assuming &apos;i&apos; is not equal to 1</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>127</integer>
<key>edges</key>
            <key>line</key><integer>127</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>127</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>127</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>127</integer>
+      <key>col</key><integer>9</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>127</integer>
+         <key>col</key><integer>9</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>127</integer>
+         <key>col</key><integer>14</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming &apos;i&apos; is equal to 1</string>
+     <key>message</key>
+     <string>Assuming &apos;i&apos; is equal to 1</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>127</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>127</integer>
+           <key>col</key><integer>9</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>128</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>128</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>

test/Analysis/Inputs/expected-plists/unix-fns.c.plist

<key>edges</key>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
            <key>line</key><integer>105</integer>
+           <key>col</key><integer>12</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>105</integer>
+           <key>col</key><integer>27</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>105</integer>
+      <key>col</key><integer>12</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>105</integer>
+         <key>col</key><integer>12</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>105</integer>
+         <key>col</key><integer>49</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is true</string>
+     <key>message</key>
+     <string>Assuming the condition is true</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>105</integer>
+           <key>col</key><integer>12</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>105</integer>
+           <key>col</key><integer>27</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
+           <key>line</key><integer>105</integer>
            <key>col</key><integer>52</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>105</integer>
            <key>col</key><integer>64</integer>
            <key>file</key><integer>0</integer>
           </dict>
<key>edges</key>
            <key>line</key><integer>60</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>60</integer>
+           <key>col</key><integer>6</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>60</integer>
+           <key>col</key><integer>21</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>60</integer>
+      <key>col</key><integer>6</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>60</integer>
+         <key>col</key><integer>6</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>60</integer>
+         <key>col</key><integer>49</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>1</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is true</string>
+     <key>message</key>
+     <string>Assuming the condition is true</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>60</integer>
+           <key>col</key><integer>6</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>60</integer>
+           <key>col</key><integer>21</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>61</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>61</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
<key>edges</key>
            <key>line</key><integer>60</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
+           <key>line</key><integer>60</integer>
+           <key>col</key><integer>6</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>60</integer>
+           <key>col</key><integer>21</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+       </dict>
+      </array>
+    </dict>
+    <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>60</integer>
+      <key>col</key><integer>6</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>60</integer>
+         <key>col</key><integer>6</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>60</integer>
+         <key>col</key><integer>49</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>1</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is true</string>
+     <key>message</key>
+     <string>Assuming the condition is true</string>
+    </dict>
+    <dict>
+     <key>kind</key><string>control</string>
+     <key>edges</key>
+      <array>
+       <dict>
+        <key>start</key>
+         <array>
+          <dict>
+           <key>line</key><integer>60</integer>
+           <key>col</key><integer>6</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+          <dict>
+           <key>line</key><integer>60</integer>
+           <key>col</key><integer>21</integer>
+           <key>file</key><integer>0</integer>
+          </dict>
+         </array>
+        <key>end</key>
+         <array>
+          <dict>
            <key>line</key><integer>61</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>61</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>

test/Analysis/MisusedMovedObject.cpp

void reinitializationTest(int i) {
     }
     if (i == 2) { // expected-note {{Assuming 'i' is not equal to 2}} expected-note {{Taking false branch}}
       //expected-note@-1 {{Assuming 'i' is not equal to 2}} expected-note@-1 {{Taking false branch}}
       a.foo();    // no-warning
     }
   }
   {
     A a;
-    if (i == 1) { // expected-note {{Taking false branch}} expected-note {{Taking false branch}}
+    if (i == 1) { // expected-note {{Assuming 'i' is not equal to 1}} expected-note {{Taking false branch}}
+      // expected-note@-1 {{Assuming 'i' is not equal to 1}} expected-note@-1 {{Taking false branch}}
       std::move(a);
     }
-    if (i == 2) { // expected-note {{Taking false branch}} expected-note {{Taking false branch}}
+    if (i == 2) { // expected-note {{Assuming 'i' is not equal to 2}} expected-note {{Taking false branch}}
+      // expected-note@-1 {{Assuming 'i' is not equal to 2}} expected-note@-1 {{Taking false branch}}
       a = A();
       a.foo();
     }
   }
   // The built-in assignment operator should also be recognized as a
   // reinitialization. (std::move() may be called on built-in types in template
   // code.)
   {
void reinitializationTest(int i) {
   // If a path exist where we not reinitialize the variable we report a bug.
   {
     A a;
     A b;
     b = std::move(a); // expected-note {{'a' became 'moved-from' here}}
     if (i < 10) {     // expected-note {{Assuming 'i' is >= 10}} expected-note {{Taking false branch}}
       a = A();
     }
-    if (i > 5) { // expected-note {{Taking true branch}}
+    if (i > 5) { // expected-note {{Assuming 'i' is > 5}} expected-note {{Taking true branch}}
       a.foo();   // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
     }
   }
 }
 
 // Using decltype on an expression is not a use.
 void decltypeIsNotUseTest() {
   A a;
if (i > 0) { // expected-note {{Assuming 'i' is > 0}} expected-note {{Taking true branch}}
       b = std::move(a);
     } else {
       a.foo(); // no-warning
     }
   }
   // Same thing, but with a ternary operator.
   {
     A a, b;
-    i > 0 ? (void)(b = std::move(a)) : a.bar(); // no-warning  // expected-note {{'?' condition is true}}
+    i > 0 ? (void)(b = std::move(a)) : a.bar(); // no-warning  // expected-note {{Assuming 'i' is > 0}} expected-note {{'?' condition is true}}
   }
   // A variation on the theme above.
   {
     A a;
 #ifdef DFS
     a.foo() > 0 ? a.foo() : A(std::move(a)).foo(); // expected-note {{Assuming the condition is false}} expected-note {{'?' condition is false}}
 #else
     a.foo() > 0 ? a.foo() : A(std::move(a)).foo(); // expected-note {{Assuming the condition is true}} expected-note {{'?' condition is true}}

 }
 
 // The logical operators && and || sequence their operands.
 void logicalOperatorsSequenceTest() {
   {
     A a;
     if (a.foo() > 0 && A(std::move(a)).foo() > 0) { // expected-note {{Assuming the condition is false}} expected-note {{Assuming the condition is false}} 
       // expected-note@-1 {{Left side of '&&' is false}} expected-note@-1 {{Left side of '&&' is false}}
-      //expected-note@-2 {{Taking false branch}} expected-note@-2 {{Taking false branch}}
+      // expected-note@-2 {{Assuming the condition is false}} expected-note@-2 {{Assuming the condition is false}}
+      // expected-note@-3 {{Taking false branch}} expected-note@-3 {{Taking false branch}}
       A().bar();
     }
   }
   // A variation: Negate the result of the && (which pushes the && further down
   // into the AST).
   {
     A a;
     if (!(a.foo() > 0 && A(std::move(a)).foo() > 0)) { // expected-note {{Assuming the condition is false}} expected-note {{Assuming the condition is false}}
       // expected-note@-1 {{Left side of '&&' is false}} expected-note@-1 {{Left side of '&&' is false}}
-      // expected-note@-2 {{Taking true branch}} expected-note@-2 {{Taking true branch}}
+      // expected-note@-2 {{Assuming the condition is true}} expected-note@-2 {{Assuming the condition is true}}
+      // expected-note@-3 {{Taking true branch}} expected-note@-3 {{Taking true branch}}
       A().bar();
     }
   }
   {
     A a;
     if (A(std::move(a)).foo() > 0 && a.foo() > 0) { // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
       // expected-note@-1 {{'a' became 'moved-from' here}} expected-note@-1 {{Assuming the condition is true}} expected-note@-1 {{Assuming the condition is false}}
       // expected-note@-2 {{Left side of '&&' is false}} expected-note@-2 {{Left side of '&&' is true}}
-      // expected-note@-3 {{Taking false branch}}
+      // expected-note@-3 {{Assuming the condition is false}}
+      // expected-note@-4 {{Taking false branch}}
       A().bar();
     }
   }
   {
     A a;
     if (a.foo() > 0 || A(std::move(a)).foo() > 0) { // expected-note {{Assuming the condition is true}} 
-      //expected-note@-1 {{Left side of '||' is true}}
-      //expected-note@-2 {{Taking true branch}}
+      // expected-note@-1 {{Left side of '||' is true}}
+      // expected-note@-2 {{Assuming the condition is true}}
+      // expected-note@-3 {{Taking true branch}}
       A().bar();
     }
   }
   {
     A a;
     if (A(std::move(a)).foo() > 0 || a.foo() > 0) { // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
       // expected-note@-1 {{'a' became 'moved-from' here}} expected-note@-1 {{Assuming the condition is false}} expected-note@-1 {{Left side of '||' is false}}
       A().bar();

test/Analysis/NewDelete-path-notes.cpp

 // RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.NewDelete,unix.Malloc -analyzer-output=text -verify %s
 // RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.NewDelete,unix.Malloc -analyzer-output=text -analyzer-config c++-allocator-inlining=true -verify %s
 // RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.NewDelete,unix.Malloc -analyzer-output=plist %s -o %t.plist
 // RUN: cat %t.plist | %diff_plist %S/Inputs/expected-plists/NewDelete-path-notes.cpp.plist
 
 void test() {
   int *p = new int;
   // expected-note@-1 {{Memory is allocated}}
   if (p)
-    // expected-note@-1 {{Taking true branch}}
+    // expected-note@-1 {{Assuming 'p' is non-null}}
+    // expected-note@-2 {{Taking true branch}}
     delete p;
     // expected-note@-1 {{Memory is released}}
 
   delete p; // expected-warning {{Attempt to free released memory}}
   // expected-note@-1 {{Attempt to free released memory}}
 }
 
 struct Odd {

test/Analysis/conditional-path-notes.c

void testCondProblem(int *p) {
   int x = *p ? 0 : 1; // expected-warning{{Dereference of null pointer (loaded from variable 'p')}}
   // expected-note@-1 {{Dereference of null pointer (loaded from variable 'p')}}
   (void)x;
 }
 
 void testLHSProblem(int *p) {
   int x = !p ? *p : 1; // expected-warning{{Dereference of null pointer (loaded from variable 'p')}}
   // expected-note@-1 {{Assuming 'p' is null}}
-  // expected-note@-2 {{'?' condition is true}}
-  // expected-note@-3 {{Dereference of null pointer (loaded from variable 'p')}}
+  // expected-note@-2 {{Assuming 'p' is null}}
+  // expected-note@-3 {{'?' condition is true}}
+  // expected-note@-4 {{Dereference of null pointer (loaded from variable 'p')}}
   (void)x;
 }
 
 void testRHSProblem(int *p) {
   int x = p ? 1 : *p; // expected-warning{{Dereference of null pointer (loaded from variable 'p')}}
   // expected-note@-1 {{Assuming 'p' is null}}
   // expected-note@-2 {{'?' condition is false}}
   // expected-note@-3 {{Dereference of null pointer (loaded from variable 'p')}}

test/Analysis/diagnostics/Inputs/expected-plists/undef-value-param.c.plist

<array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>39</integer>
+           <key>line</key><integer>40</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>39</integer>
+           <key>line</key><integer>40</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>40</integer>
+           <key>line</key><integer>41</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>40</integer>
+           <key>line</key><integer>41</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>40</integer>
+      <key>line</key><integer>41</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>40</integer>
+         <key>line</key><integer>41</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>40</integer>
+         <key>line</key><integer>41</integer>
          <key>col</key><integer>21</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling &apos;initArray&apos;</string>
<key>edges</key>
            <key>line</key><integer>31</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>33</integer>
+           <key>line</key><integer>34</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>33</integer>
+           <key>line</key><integer>34</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>40</integer>
+      <key>line</key><integer>41</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>40</integer>
+         <key>line</key><integer>41</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>40</integer>
+         <key>line</key><integer>41</integer>
          <key>col</key><integer>21</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Returning from &apos;initArray&apos;</string>
      <key>message</key>
      <string>Returning from &apos;initArray&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>40</integer>
+           <key>line</key><integer>41</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>40</integer>
+           <key>line</key><integer>41</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>42</integer>
+           <key>line</key><integer>43</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>42</integer>
+           <key>line</key><integer>43</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>42</integer>
+      <key>line</key><integer>43</integer>
       <key>col</key><integer>14</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>42</integer>
+         <key>line</key><integer>43</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>42</integer>
+         <key>line</key><integer>43</integer>
          <key>col</key><integer>21</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>The right operand of &apos;*&apos; is a garbage value</string>
      <key>message</key>
      <string>The right operand of &apos;*&apos; is a garbage value</string>
     </dict>
    </array>
    <key>description</key><string>The right operand of &apos;*&apos; is a garbage value</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Result of operation is garbage or undefined</string>
    <key>check_name</key><string>core.UndefinedBinaryOperatorResult</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>96cf3258da3df14d13cd5c2236c9cb27</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testPassingParentRegionArray</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>42</integer>
+   <key>line</key><integer>43</integer>
    <key>col</key><integer>14</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
     <integer>30</integer>
     <integer>31</integer>
-    <integer>33</integer>
-    <integer>38</integer>
+    <integer>34</integer>
     <integer>39</integer>
     <integer>40</integer>
-    <integer>42</integer>
+    <integer>41</integer>
+    <integer>43</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>58</integer>
+           <key>line</key><integer>60</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>58</integer>
+           <key>line</key><integer>60</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>61</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>61</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>59</integer>
+      <key>line</key><integer>61</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>59</integer>
+         <key>line</key><integer>61</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>59</integer>
+         <key>line</key><integer>61</integer>
          <key>col</key><integer>11</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Null pointer value stored to &apos;st.f1&apos;</string>
      <key>message</key>
      <string>Null pointer value stored to &apos;st.f1&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>61</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>59</integer>
+           <key>line</key><integer>61</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>60</integer>
+           <key>line</key><integer>62</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>60</integer>
+           <key>line</key><integer>62</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>60</integer>
+      <key>line</key><integer>62</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>60</integer>
+         <key>line</key><integer>62</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>60</integer>
+         <key>line</key><integer>62</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling &apos;initStruct&apos;</string>
      <key>message</key>
      <string>Calling &apos;initStruct&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>50</integer>
+      <key>line</key><integer>51</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;testPassingParentRegionStruct&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;testPassingParentRegionStruct&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>50</integer>
+           <key>line</key><integer>51</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>50</integer>
+           <key>line</key><integer>51</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>51</integer>
+           <key>line</key><integer>52</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>51</integer>
+           <key>line</key><integer>52</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>51</integer>
+           <key>line</key><integer>52</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>51</integer>
+           <key>line</key><integer>52</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>51</integer>
+           <key>line</key><integer>52</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>51</integer>
+           <key>line</key><integer>52</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>51</integer>
+      <key>line</key><integer>52</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>51</integer>
+         <key>line</key><integer>52</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>51</integer>
+         <key>line</key><integer>52</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Assuming &apos;x&apos; is &lt;= 0</string>
      <key>message</key>
      <string>Assuming &apos;x&apos; is &lt;= 0</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>51</integer>
+           <key>line</key><integer>52</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>51</integer>
+           <key>line</key><integer>52</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>54</integer>
+           <key>line</key><integer>56</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>54</integer>
+           <key>line</key><integer>56</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>54</integer>
+           <key>line</key><integer>56</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>54</integer>
+           <key>line</key><integer>56</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>54</integer>
+           <key>line</key><integer>56</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>54</integer>
+           <key>line</key><integer>56</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>54</integer>
+      <key>line</key><integer>56</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Returning without writing to &apos;X-&gt;f1&apos;</string>
      <key>message</key>
      <string>Returning without writing to &apos;X-&gt;f1&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>54</integer>
+           <key>line</key><integer>56</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>54</integer>
+           <key>line</key><integer>56</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>54</integer>
+           <key>line</key><integer>56</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>54</integer>
+           <key>line</key><integer>56</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>60</integer>
+      <key>line</key><integer>62</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>60</integer>
+         <key>line</key><integer>62</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>60</integer>
+         <key>line</key><integer>62</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Returning from &apos;initStruct&apos;</string>
      <key>message</key>
      <string>Returning from &apos;initStruct&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>60</integer>
+           <key>line</key><integer>62</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>60</integer>
+           <key>line</key><integer>62</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>62</integer>
+           <key>line</key><integer>64</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>62</integer>
+           <key>line</key><integer>64</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>62</integer>
+           <key>line</key><integer>64</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>62</integer>
+           <key>line</key><integer>64</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>62</integer>
+           <key>line</key><integer>64</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>62</integer>
+           <key>line</key><integer>64</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>62</integer>
+      <key>line</key><integer>64</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>62</integer>
+         <key>line</key><integer>64</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>62</integer>
+         <key>line</key><integer>64</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Dereference of null pointer (loaded from field &apos;f1&apos;)</string>
      <key>message</key>
      <string>Dereference of null pointer (loaded from field &apos;f1&apos;)</string>
     </dict>
    </array>
    <key>description</key><string>Dereference of null pointer (loaded from field &apos;f1&apos;)</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>299055864402de225b0ab4f2ecd8e76c</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testPassingParentRegionStruct</string>
   <key>issue_hash_function_offset</key><string>5</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>62</integer>
+   <key>line</key><integer>64</integer>
    <key>col</key><integer>10</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>50</integer>
     <integer>51</integer>
-    <integer>54</integer>
-    <integer>57</integer>
-    <integer>58</integer>
+    <integer>52</integer>
+    <integer>56</integer>
     <integer>59</integer>
     <integer>60</integer>
+    <integer>61</integer>
     <integer>62</integer>
+    <integer>64</integer>
    </array>
   </dict>
   </dict>
  </array>
  <key>files</key>
  <array>
    <string>/clang/test/Analysis/diagnostics/undef-value-param.c</string>
  </array>
 </dict>
-</plist>
+</plist>
 No newline at end of file

test/Analysis/diagnostics/macros.cpp

 // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,osx -analyzer-output=text -verify %s
 
 #include "../Inputs/system-header-simulator.h"
 #include "../Inputs/system-header-simulator-cxx.h"
 
 void testIntMacro(unsigned int i) {
   if (i == UINT32_MAX) { // expected-note {{Assuming 'i' is equal to UINT32_MAX}}
-                         // expected-note@-1 {{Taking true branch}}
+                         // expected-note@-1 {{Assuming 'i' is equal to UINT32_MAX}}
+                         // expected-note@-2 {{Taking true branch}}
     char *p = NULL; // expected-note {{'p' initialized to a null pointer value}}
     *p = 7;  // expected-warning {{Dereference of null pointer (loaded from variable 'p')}}
              // expected-note@-1 {{Dereference of null pointer (loaded from variable 'p')}}
   }
 }
 
 void testNULLMacro(int *p) {
   if (p == NULL) { // expected-note {{Assuming 'p' is equal to NULL}}
-                   // expected-note@-1 {{Taking true branch}}
+                   // expected-note@-1 {{Assuming 'p' is equal to NULL}}
+                   // expected-note@-2 {{Taking true branch}}
     *p = 7;  // expected-warning {{Dereference of null pointer (loaded from variable 'p')}}
              // expected-note@-1 {{Dereference of null pointer (loaded from variable 'p')}}
   }
 }
 
 void testnullptrMacro(int *p) {
   if (p == nullptr) { // expected-note {{Assuming pointer value is null}}
-                      // expected-note@-1 {{Taking true branch}}
+                      // expected-note@-1 {{Assuming the condition is true}}
+                      // expected-note@-2 {{Taking true branch}}
     *p = 7;  // expected-warning {{Dereference of null pointer (loaded from variable 'p')}}
              // expected-note@-1 {{Dereference of null pointer (loaded from variable 'p')}}
   }
 }
 
 // There are no path notes on the comparison to float types.
 void testDoubleMacro(double d) {
-  if (d == DBL_MAX) { // expected-note {{Taking true branch}}
+  if (d == DBL_MAX) { // expected-note {{Assuming 'd' is equal to DBL_MAX}}
+                      // expected-note@-1 {{Taking true branch}}
 
     char *p = NULL; // expected-note {{'p' initialized to a null pointer value}}
     *p = 7;         // expected-warning {{Dereference of null pointer (loaded from variable 'p')}}
                     // expected-note@-1 {{Dereference of null pointer (loaded from variable 'p')}}
   }
 }
 
 void testboolMacro(bool b, int *p) {
   p = nullptr;      // expected-note {{Null pointer value stored to 'p'}}
   if (b == false) { // expected-note {{Assuming the condition is true}}
-                    // expected-note@-1 {{Taking true branch}}
+                    // expected-note@-1 {{Assuming the condition is true}}
+                    // expected-note@-2 {{Taking true branch}}
     *p = 7;         // expected-warning {{Dereference of null pointer (loaded from variable 'p')}}
                     // expected-note@-1 {{Dereference of null pointer (loaded from variable 'p')}}
   }
 }

test/Analysis/diagnostics/macros.m

 // RUN: %clang_analyze_cc1 -analyzer-checker=core,osx -fblocks -analyzer-output=text -verify %s
 
 #include "../Inputs/system-header-simulator-objc.h"
 
 @interface NSDictionary : NSObject
 - (NSUInteger)count;
 - (id)objectForKey:(id)aKey;
 - (NSEnumerator *)keyEnumerator;
 @end
 @interface NSMutableDictionary : NSDictionary
 - (void)setObject:(id)anObject forKey:(id <NSCopying>)aKey;
 @end
 
 void testBOOLMacro(BOOL b) {
   if (b == YES) { // expected-note {{Assuming 'b' is equal to YES}}
-                  // expected-note@-1 {{Taking true branch}}
+                  // expected-note@-1 {{Assuming 'b' is equal to YES}}
+                  // expected-note@-2 {{Taking true branch}}
     char *p = NULL;// expected-note {{'p' initialized to a null pointer value}}
     *p = 7;  // expected-warning {{Dereference of null pointer (loaded from variable 'p')}}
              // expected-note@-1 {{Dereference of null pointer (loaded from variable 'p')}}
   }
 }
 
 void testNilMacro(NSMutableDictionary *d, NSObject *o) {
   if (o == nil) // expected-note {{Assuming 'o' is equal to nil}}
-                // expected-note@-1 {{Taking true branch}}
+                // expected-note@-1 {{Assuming 'o' is equal to nil}}
+                // expected-note@-2 {{Taking true branch}}
     [d setObject:o forKey:[o description]]; // expected-warning {{Key argument to 'setObject:forKey:' cannot be nil}}
                                             // expected-note@-1 {{'description' not called because the receiver is nil}}
                                             // expected-note@-2 {{Key argument to 'setObject:forKey:' cannot be nil}}
 
   return;
 }

test/Analysis/diagnostics/no-store-func-path-notes.c

 // RUN: %clang_analyze_cc1 -x c -analyzer-checker=core -analyzer-output=text -verify %s
 
 typedef __typeof(sizeof(int)) size_t;
 void *memset(void *__s, int __c, size_t __n);
 
 int initializer1(int *p, int x) {
-  if (x) { // expected-note{{Taking false branch}}
+  if (x) { // expected-note{{Assuming 'x' is 0}}
+     // expected-note@-1{{Taking false branch}}
     *p = 1;
     return 0;
   } else {
     return 1; // expected-note {{Returning without writing to '*p'}}
   }
 }
 
 int param_not_initialized_by_func() {
   int p; // expected-note {{'p' declared without an initial value}}
   int out = initializer1(&p, 0); // expected-note{{Calling 'initializer1'}}
                                  // expected-note@-1{{Returning from 'initializer1'}}
   return p; // expected-note{{Undefined or garbage value returned to caller}}
             // expected-warning@-1{{Undefined or garbage value returned to caller}}
 }
 
 int param_initialized_properly() {
   int p;
   int out = initializer1(&p, 1);
   return p; //no-warning
 }
 
 static int global;
 
 int initializer2(int **p, int x) {
-  if (x) { // expected-note{{Taking false branch}}
+  if (x) { // expected-note{{Assuming 'x' is 0}}
+           // expected-note@-1{{Taking false branch}}
     *p = &global;
     return 0;
   } else {
     return 1; // expected-note {{Returning without writing to '*p'}}
   }
 }
 
 int param_not_written_into_by_func() {
   int *p = 0;                    // expected-note{{'p' initialized to a null pointer value}}
   int out = initializer2(&p, 0); // expected-note{{Calling 'initializer2'}}
                                  // expected-note@-1{{Returning from 'initializer2'}}
   return *p;                     // expected-warning{{Dereference of null pointer (loaded from variable 'p')}}
                                  // expected-note@-1{{Dereference of null pointer (loaded from variable 'p')}}
 }
 
 void initializer3(int *p, int param) {
-  if (param) // expected-note{{Taking false branch}}
+  if (param) // expected-note{{Assuming 'param' is 0}}
+             // expected-note@-1{{Taking false branch}}
     *p = 0;
 } // expected-note{{Returning without writing to '*p'}}
 
 int param_written_into_by_void_func() {
   int p;               // expected-note{{'p' declared without an initial value}}
   initializer3(&p, 0); // expected-note{{Calling 'initializer3'}}
                        // expected-note@-1{{Returning from 'initializer3'}}
   return p;            // expected-warning{{Undefined or garbage value returned to caller}}
                        // expected-note@-1{{Undefined or garbage value returned to caller}}
 }
 
 void initializer4(int *p, int param) {
-  if (param) // expected-note{{Taking false branch}}
+  if (param) // expected-note{{Assuming 'param' is 0}} 
+             // expected-note@-1{{Taking false branch}}
     *p = 0;
 } // expected-note{{Returning without writing to '*p'}}
 
 void initializer5(int *p, int param) {
-  if (!param) // expected-note{{Taking false branch}}
+  if (!param) // expected-note{{Assuming 'param' is not equal to 0}}
+              // expected-note@-1{{Taking false branch}}
     *p = 0;
 } // expected-note{{Returning without writing to '*p'}}
 
 int multi_init_tries_func() {
   int p;               // expected-note{{'p' declared without an initial value}}
   initializer4(&p, 0); // expected-note{{Calling 'initializer4'}}
                        // expected-note@-1{{Returning from 'initializer4'}}
   initializer5(&p, 1); // expected-note{{Calling 'initializer5'}}
return p; // expected-warning{{Undefined or garbage value returned to caller}}
             // expected-note@-1{{Undefined or garbage value returned to caller}}
 }
 
 typedef struct {
   int x;
 } S;
 
 int initializer7(S *s, int param) {
-  if (param) { // expected-note{{Taking false branch}}
+  if (param) { // expected-note{{Assuming 'param' is 0}}
+               // expected-note@-1{{Taking false branch}}
     s->x = 0;
     return 0;
   }
   return 1; // expected-note{{Returning without writing to 's->x'}}
 }
 
 int initialize_struct_field() {
   S local;

test/Analysis/diagnostics/no-store-func-path-notes.cpp

 // RUN: %clang_analyze_cc1 -x c++ -std=c++14 -analyzer-checker=core -analyzer-output=text -verify %s
 
 int initializer1(int &p, int x) {
-  if (x) { // expected-note{{Taking false branch}}
+  if (x) { // expected-note{{Assuming 'x' is 0}}
+           // expected-note@-1{{Taking false branch}}
     p = 1;
     return 0;
   } else {
     return 1; // expected-note {{Returning without writing to 'p'}}
   }
 }
 
 int param_not_initialized_by_func() {
   int outP;                        // expected-note {{'outP' declared without an initial value}}
   int out = initializer1(outP, 0); // expected-note{{Calling 'initializer1'}}
                                 // expected-note@-1{{Returning from 'initializer1'}}
   return outP;                     // expected-note{{Undefined or garbage value returned to caller}}
                                 // expected-warning@-1{{Undefined or garbage value returned to caller}}
 }
 
 struct S {
   int initialize(int *p, int param) {
-    if (param) { //expected-note{{Taking false branch}}
+    if (param) { // expected-note{{Assuming 'param' is 0}}
+                 // expected-note@-1{{Taking false branch}}
       *p = 1;
       return 1;
     }
     return 0; // expected-note{{Returning without writing to '*p'}}
   }
 };
 
 int use(S *s) {

test/Analysis/diagnostics/no-store-func-path-notes.m

 // RUN: %clang_analyze_cc1 -x objective-c -analyzer-checker=core,nullability -analyzer-output=text -Wno-objc-root-class -fblocks -verify %s
 
 #include "../Inputs/system-header-simulator-for-nullability.h"
 
 extern int coin();
 
 @interface I : NSObject
 - (int)initVar:(int *)var param:(int)param;
 @end
 
 @implementation I
 - (int)initVar:(int *)var param:(int)param {
-  if (param) { // expected-note{{Taking false branch}}
+  if (param) { // expected-note{{Assuming 'param' is 0}}
+               // expected-note@-1{{Taking false branch}}
     *var = 1;
     return 0;
   }
   return 1; // expected-note{{Returning without writing to '*var'}}
 }
 @end
 
 int foo(I *i) {
   int x;                            //expected-note{{'x' declared without an initial value}}
   int out = [i initVar:&x param:0]; //expected-note{{Calling 'initVar:param:'}}
                                     //expected-note@-1{{Returning from 'initVar:param:'}}
-  if (out)                          // expected-note{{Taking true branch}}
+  if (out)                          // expected-note{{Assuming 'out' is not equal to 0}}
+                                    // expected-note@-1{{Taking true branch}}
     return x;                       //expected-warning{{Undefined or garbage value returned to caller}}
                                     //expected-note@-1{{Undefined or garbage value returned to caller}}
   return 0;
 }
 
 int initializer1(int *p, int x) {
-  if (x) { // expected-note{{Taking false branch}}
+  if (x) { // expected-note{{Assuming 'x' is 0}}
+           // expected-note@-1{{Taking false branch}}
     *p = 1;
     return 0;
   } else {
     return 1; // expected-note {{Returning without writing to '*p'}}
   }
 }
 
 int initFromBlock() {

test/Analysis/diagnostics/undef-value-param.c

int use(int c) {
     foo_irrelevant(c);
     return xx+3; //expected-warning{{The left operand of '+' is a garbage value}}
                  //expected-note@-1{{The left operand of '+' is a garbage value}}
 }
 
 void initArray(int x, double XYZ[3]) {
     if (x <= 0) //expected-note {{Taking true branch}}
                 //expected-note@-1 {{Assuming 'x' is <= 0}}
+                //expected-note@-2 {{Assuming 'x' is <= 0}}
         return;
     XYZ[0] = 1;
     XYZ[1] = 1;
     XYZ[2] = 1;
 }
 int testPassingParentRegionArray(int x) {
     double XYZ[3];
     initArray(x, XYZ); //expected-note {{Calling 'initArray'}}
                        //expected-note@-1 {{Returning from 'initArray'}}
     return 1 * XYZ[1]; //expected-warning {{The right operand of '*' is a garbage value}}
                        //expected-note@-1 {{The right operand of '*' is a garbage value}}
 }
 
 double *getValidPtr();
 struct WithFields {
   double *f1;
 };
 void initStruct(int x, struct WithFields *X) {
   if (x <= 0) //expected-note {{Taking true branch}}
               //expected-note@-1 {{Assuming 'x' is <= 0}}
+              //expected-note@-2 {{Assuming 'x' is <= 0}}
 
     return; //expected-note{{Returning without writing to 'X->f1'}}
   X->f1 = getValidPtr();
 }
 double testPassingParentRegionStruct(int x) {
   struct WithFields st;
   st.f1 = 0; // expected-note {{Null pointer value stored to 'st.f1'}}
   initStruct(x, &st); //expected-note {{Calling 'initStruct'}}
                       //expected-note@-1 {{Returning from 'initStruct'}}
   return (*st.f1); //expected-warning {{Dereference of null pointer}}
                    //expected-note@-1{{Dereference of null pointer (loaded from field 'f1')}}
 }
 

test/Analysis/inline-plist.c

 void bar(int *p) {
   if (!!p) {
     // expected-note@-1 {{Assuming 'p' is null}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (p == 0) {
-    // expected-note@-1 {{Taking true branch}}
+    // expected-note@-1 {{Assuming 'p' is equal to null}}
+    // expected-note@-2 {{Taking true branch}}
     triggers_bug(p);
     // expected-note@-1 {{Passing null pointer value via 1st parameter 'p'}}
     // expected-note@-2 {{Calling 'triggers_bug'}}
   }
 }
 
 // ========================================================================== //
 // Test inlining of blocks.

test/Analysis/inlining/Inputs/expected-plists/path-notes.cpp.plist

<array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming pointer value is null</string>
      <key>message</key>
      <string>Assuming pointer value is null</string>
     </dict>
     <dict>
+     <key>kind</key><string>event</string>
+     <key>location</key>
+     <dict>
+      <key>line</key><integer>259</integer>
+      <key>col</key><integer>7</integer>
+      <key>file</key><integer>0</integer>
+     </dict>
+     <key>ranges</key>
+     <array>
+       <array>
+        <dict>
+         <key>line</key><integer>259</integer>
+         <key>col</key><integer>7</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+        <dict>
+         <key>line</key><integer>259</integer>
+         <key>col</key><integer>15</integer>
+         <key>file</key><integer>0</integer>
+        </dict>
+       </array>
+     </array>
+     <key>depth</key><integer>0</integer>
+     <key>extended_message</key>
+     <string>Assuming the condition is true</string>
+     <key>message</key>
+     <string>Assuming the condition is true</string>
+    </dict>
+    <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
            <key>line</key><integer>259</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
            <key>line</key><integer>259</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>261</integer>
+           <key>line</key><integer>262</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>261</integer>
+           <key>line</key><integer>262</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>261</integer>
+      <key>line</key><integer>262</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>261</integer>
+         <key>line</key><integer>262</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>261</integer>
+         <key>line</key><integer>262</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Called C++ object pointer is null</string>
      <key>message</key>
      <string>Called C++ object pointer is null</string>
     </dict>
    </array>
    <key>description</key><string>Called C++ object pointer is null</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Called C++ object pointer is null</string>
    <key>check_name</key><string>core.CallAndMessage</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>8b577b362ffa5a7290d00d03635c1fca</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testDeclRefExprToReferenceInGetDerefExpr</string>
-  <key>issue_hash_function_offset</key><string>8</string>
+  <key>issue_hash_function_offset</key><string>9</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>261</integer>
+   <key>line</key><integer>262</integer>
    <key>col</key><integer>5</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
     <integer>253</integer>
     <integer>254</integer>
     <integer>259</integer>
-    <integer>261</integer>
+    <integer>262</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>273</integer>
+           <key>line</key><integer>274</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>273</integer>
+           <key>line</key><integer>274</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>273</integer>
+           <key>line</key><integer>274</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>273</integer>
+           <key>line</key><integer>274</integer>
            <key>col</key><integer>38</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>273</integer>
+      <key>line</key><integer>274</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>273</integer>
+         <key>line</key><integer>274</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>273</integer>
+         <key>line</key><integer>274</integer>
          <key>col</key><integer>41</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Passing the value 0 via 2nd parameter &apos;two&apos;</string>
      <key>message</key>
      <string>Passing the value 0 via 2nd parameter &apos;two&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>273</integer>
+      <key>line</key><integer>274</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>273</integer>
+         <key>line</key><integer>274</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>273</integer>
+         <key>line</key><integer>274</integer>
          <key>col</key><integer>41</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling &apos;generateNoteOnDefaultArgument&apos;</string>
      <key>message</key>
      <string>Calling &apos;generateNoteOnDefaultArgument&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>268</integer>
+      <key>line</key><integer>269</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;callGenerateNoteOnDefaultArgument&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;callGenerateNoteOnDefaultArgument&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>268</integer>
+           <key>line</key><integer>269</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>268</integer>
+           <key>line</key><integer>269</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>269</integer>
+           <key>line</key><integer>270</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>269</integer>
+           <key>line</key><integer>270</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>269</integer>
+      <key>line</key><integer>270</integer>
       <key>col</key><integer>13</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>269</integer>
+         <key>line</key><integer>270</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>269</integer>
+         <key>line</key><integer>270</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Division by zero</string>
      <key>message</key>
      <string>Division by zero</string>
     </dict>
    </array>
    <key>description</key><string>Division by zero</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Division by zero</string>
    <key>check_name</key><string>core.DivideZero</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>f7fcdbc77cfb95588c0e5b606288013d</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>generateNoteOnDefaultArgument</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>269</integer>
+   <key>line</key><integer>270</integer>
    <key>col</key><integer>13</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>268</integer>
     <integer>269</integer>
-    <integer>272</integer>
+    <integer>270</integer>
     <integer>273</integer>
+    <integer>274</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>296</integer>
+      <key>line</key><integer>297</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>296</integer>
+         <key>line</key><integer>297</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>296</integer>
+         <key>line</key><integer>297</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling &apos;~Outer&apos;</string>
      <key>message</key>
      <string>Calling &apos;~Outer&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>289</integer>
+      <key>line</key><integer>290</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;test&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;test&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>289</integer>
+           <key>line</key><integer>290</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>289</integer>
+           <key>line</key><integer>290</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>290</integer>
+           <key>line</key><integer>291</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>290</integer>
+           <key>line</key><integer>291</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>290</integer>
+      <key>line</key><integer>291</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>290</integer>
+         <key>line</key><integer>291</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>290</integer>
+         <key>line</key><integer>291</integer>
          <key>col</key><integer>18</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Calling &apos;~Inner&apos;</string>
      <key>message</key>
      <string>Calling &apos;~Inner&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>280</integer>
+      <key>line</key><integer>281</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>2</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;~Outer&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;~Outer&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>280</integer>
+           <key>line</key><integer>281</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>280</integer>
+           <key>line</key><integer>281</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>281</integer>
+           <key>line</key><integer>282</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>281</integer>
+           <key>line</key><integer>282</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>281</integer>
+           <key>line</key><integer>282</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>281</integer>
+           <key>line</key><integer>282</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>281</integer>
+           <key>line</key><integer>282</integer>
            <key>col</key><integer>26</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>281</integer>
+           <key>line</key><integer>282</integer>
            <key>col</key><integer>26</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>281</integer>
+      <key>line</key><integer>282</integer>
       <key>col</key><integer>26</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>281</integer>
+         <key>line</key><integer>282</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>281</integer>
+         <key>line</key><integer>282</integer>
          <key>col</key><integer>28</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>2</integer>
      <key>extended_message</key>
      <string>Dereference of null pointer</string>
      <key>message</key>
      <string>Dereference of null pointer</string>
     </dict>
    </array>
    <key>description</key><string>Dereference of null pointer</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>ff61a6b893cd2d64c7ccaa2a9805311d</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>281</integer>
+   <key>line</key><integer>282</integer>
    <key>col</key><integer>26</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>280</integer>
     <integer>281</integer>
-    <integer>289</integer>
+    <integer>282</integer>
     <integer>290</integer>
-    <integer>295</integer>
+    <integer>291</integer>
     <integer>296</integer>
+    <integer>297</integer>
    </array>
   </dict>
   </dict>
  </array>
  <key>files</key>
  <array>
    <string>/clang/test/Analysis/inlining/path-notes.cpp</string>
  </array>
 </dict>
-</plist>
+</plist>
 No newline at end of file

test/Analysis/inlining/path-notes.cpp

 };
 const A& testDeclRefExprToReferenceInGetDerefExpr(const A *ptr) {
   const A& val = *ptr; //expected-note {{'val' initialized here}}
 
   // This is not valid C++; if 'ptr' were null, creating 'ref' would be illegal.
   // However, this is not checked at runtime, so this branch is actually
   // possible.
   if (&val == 0) { //expected-note {{Assuming pointer value is null}}
-                   // expected-note@-1 {{Taking true branch}}
+                   // expected-note@-1 {{Assuming the condition is true}}
+                   // expected-note@-2 {{Taking true branch}}
     val.bar(); // expected-warning {{Called C++ object pointer is null}}
                // expected-note@-1 {{Called C++ object pointer is null}}
   }
 
   return val;
 }
 
 int generateNoteOnDefaultArgument(int one, int two = 0) {

test/Analysis/keychainAPI-diagnostic-visitor.m

 void DellocWithCFStringCreate4() {
     unsigned int *ptr = 0;
     OSStatus st = 0;
     UInt32 length;
     char *bytes;
     char *x;
     st = SecKeychainItemCopyContent(2, ptr, ptr, &length, (void **)&bytes); // expected-note {{Data is allocated here}}
     x = bytes;
-    if (st == noErr) // expected-note {{Assuming 'st' is equal to noErr}} // expected-note{{Taking true branch}}
+    if (st == noErr) // expected-note {{Assuming 'st' is equal to noErr}} // expected-note {{Assuming 'st' is equal to noErr}} // expected-note{{Taking true branch}}
         x = bytes;;
   
     length++; // expected-warning {{Allocated data is not released}} // expected-note{{Allocated data is not released}}
 }
 

test/Analysis/method-call-path-notes.cpp

 
 void test_ic_set_to_null() {
   TestInstanceCall *p;
   p = 0; // expected-note {{Null pointer value stored to 'p'}}
   p->foo(); // expected-warning {{Called C++ object pointer is null}} expected-note {{Called C++ object pointer is null}}
 }
 
 void test_ic_null(TestInstanceCall *p) {
-  if (!p) // expected-note {{Assuming 'p' is null}} expected-note {{Taking true branch}}
+  if (!p) // expected-note {{Assuming 'p' is null}} expected-note {{Assuming 'p' is null}} expected-note {{Taking true branch}}
     p->foo(); // expected-warning {{Called C++ object pointer is null}} expected-note{{Called C++ object pointer is null}}
 }
 
 void test_ic_member_ptr() {
   TestInstanceCall *p = 0; // expected-note {{'p' initialized to a null pointer value}}
   typedef void (TestInstanceCall::*IC_Ptr)();
   IC_Ptr bar = &TestInstanceCall::foo;
   (p->*bar)(); // expected-warning {{Called C++ object pointer is null}} expected-note{{Called C++ object pointer is null}}
 }
 
 void test_cast(const TestInstanceCall *p) {
-  if (!p) // expected-note {{Assuming 'p' is null}} expected-note {{Taking true branch}}
+  if (!p) // expected-note {{Assuming 'p' is null}} expected-note {{Assuming 'p' is null}} expected-note {{Taking true branch}}
     const_cast<TestInstanceCall *>(p)->foo(); // expected-warning {{Called C++ object pointer is null}} expected-note {{Called C++ object pointer is null}}
 }
 

test/Analysis/new-ctor-malloc.cpp

 // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection,unix.Malloc -analyzer-config c++-allocator-inlining=true -analyzer-output=text -std=c++11 -verify %s
 
 void clang_analyzer_eval(bool);
 
 typedef __typeof__(sizeof(int)) size_t;
 
 void *malloc(size_t size);
 
 void *operator new(size_t size) throw() {
   void *x = malloc(size); // expected-note {{Memory is allocated}}
   if (!x) // expected-note    {{Assuming 'x' is non-null}}
-          // expected-note@-1 {{Taking false branch}}
+          // expected-note@-1 {{Assuming 'x' is non-null}}
+          // expected-note@-2 {{Taking false branch}}
     return nullptr;
   return x;
 }
 
 void checkNewAndConstructorInlining() {
   int *s = new int; // expected-note   {{Calling 'operator new'}}
                     // expected-note@-1{{Returning from 'operator new'}}
 } // expected-warning {{Potential leak of memory pointed to by 's'}}
   // expected-note@-1 {{Potential leak of memory pointed to by 's'}}

test/Analysis/non-diagnosable-assumptions.c

void test_false() {
   }
 }
 
 // Test that we're still reporting that the condition is true,
 // when we encounter an exclamation mark (used to be broken).
 void test_exclamation_mark() {
   if (!non_diagnosable()) {
     // expected-note@-1{{Assuming the condition is true}}
-    // expected-note@-2{{Taking true branch}}
+    // expected-note@-2{{Assuming the condition is true}}
+    // expected-note@-3{{Taking true branch}}
     1 / 0;
     // expected-warning@-1{{Division by zero}}
     // expected-note@-2{{Division by zero}}
   }
 }

test/Analysis/uninit-vals.c

int f5(void) {
   struct f5_struct s;
   f5_aux(&s);
   return s.x; // no-warning
 }
 
 void f6(int x) {
   int a[20];
   if (x == 25) {} // expected-note{{Assuming 'x' is equal to 25}}
-                  // expected-note@-1{{Taking true branch}}
+                  // expected-note@-1{{Assuming 'x' is equal to 25}}
+                  // expected-note@-2{{Taking true branch}}
   if (a[x] == 123) {} // expected-warning{{The left operand of '==' is a garbage value due to array index out of bounds}}
                       // expected-note@-1{{The left operand of '==' is a garbage value due to array index out of bounds}}
 }
 
 int ret_uninit() {
   int i; // expected-note{{'i' declared without an initial value}}
   int *p = &i;
   return *p;  // expected-warning{{Undefined or garbage value returned to caller}}

test/Analysis/uninit-vals.m

 
 void PR14765_test() {
   Circle *testObj = calloc(sizeof(Circle), 1);
 
   clang_analyzer_eval(testObj->size == 0); // expected-warning{{TRUE}}
                                            // expected-note@-1{{TRUE}}
 
   testObj->origin = makePoint(0.0, 0.0);
-  if (testObj->size > 0) { ; } // expected-note{{Taking false branch}}
+  if (testObj->size > 0) { ; } // expected-note{{Assuming the condition is false}}
+                               // expected-note@-1{{Taking false branch}}
 
   // FIXME: Assigning to 'testObj->origin' kills the default binding for the
   // whole region, meaning that we've forgotten that testObj->size should also
   // default to 0. Tracked by <rdar://problem/12701038>.
   // This should be TRUE.
   clang_analyzer_eval(testObj->size == 0); // expected-warning{{UNKNOWN}}
                                            // expected-note@-1{{UNKNOWN}}
 
clang_analyzer_eval(testObj->size == 0); // expected-warning{{TRUE}}
                                            // expected-note@-1{{TRUE}}
   clang_analyzer_eval(testObj->origin.x == 0); // expected-warning{{TRUE}}
                                                // expected-note@-1{{TRUE}}
   clang_analyzer_eval(testObj->origin.y == 0); // expected-warning{{TRUE}}
                                                // expected-note@-1{{TRUE}}
   clang_analyzer_eval(testObj->origin.z == 0); // expected-warning{{TRUE}}
                                                // expected-note@-1{{TRUE}}
 
   testObj->origin = makeIntPoint(1, 2);
-  if (testObj->size > 0) { ; } // expected-note{{Taking false branch}}
-                               // expected-note@-1{{Taking false branch}}
-                               // expected-note@-2{{Taking false branch}}
-                               // expected-note@-3{{Taking false branch}}
+  if (testObj->size > 0) { ; } // expected-note{{Assuming the condition is false}}
+                               // expected-note@-1{{Assuming the condition is false}}
+                               // expected-note@-2{{Assuming the condition is false}}
+                               // expected-note@-3{{Assuming the condition is false}}
+                               // expected-note@-4{{Taking false branch}}
+                               // expected-note@-5{{Taking false branch}}
+                               // expected-note@-6{{Taking false branch}}
+                               // expected-note@-7{{Taking false branch}}
 
   // FIXME: Assigning to 'testObj->origin' kills the default binding for the
   // whole region, meaning that we've forgotten that testObj->size should also
   // default to 0. Tracked by <rdar://problem/12701038>.
   // This should be TRUE.
   clang_analyzer_eval(testObj->size == 0); // expected-warning{{UNKNOWN}}
                                            // expected-note@-1{{UNKNOWN}}
   clang_analyzer_eval(testObj->origin.x == 1); // expected-warning{{TRUE}}
void testSmallStructInLargerStruct() {
 
   clang_analyzer_eval(testObj->size == 0); // expected-warning{{TRUE}}
                                            // expected-note@-1{{TRUE}}
   clang_analyzer_eval(testObj->origin.x == 0); // expected-warning{{TRUE}}
                                                // expected-note@-1{{TRUE}}
   clang_analyzer_eval(testObj->origin.y == 0); // expected-warning{{TRUE}}
                                                // expected-note@-1{{TRUE}}
 
   testObj->origin = makeIntPoint2D(1, 2);
-  if (testObj->size > 0) { ; } // expected-note{{Taking false branch}}
-                               // expected-note@-1{{Taking false branch}}
-                               // expected-note@-2{{Taking false branch}}
+  if (testObj->size > 0) { ; } // expected-note{{Assuming the condition is false}}
+                               // expected-note@-1{{Assuming the condition is false}}
+                               // expected-note@-2{{Assuming the condition is false}}
+                               // expected-note@-3{{Taking false branch}}
+                               // expected-note@-4{{Taking false branch}}
+                               // expected-note@-5{{Taking false branch}}
 
   clang_analyzer_eval(testObj->size == 0); // expected-warning{{TRUE}}
                                            // expected-note@-1{{TRUE}}
   clang_analyzer_eval(testObj->origin.x == 1); // expected-warning{{TRUE}}
                                                // expected-note@-1{{TRUE}}
   clang_analyzer_eval(testObj->origin.y == 2); // expected-warning{{TRUE}}
                                                // expected-note@-1{{TRUE}}
 

test/Analysis/virtualcall.cpp

#if !PUREONLY
     // expected-warning-re@-2 {{{{^}}Call to virtual function during construction}}
   // expected-note-re@-3 {{{{^}}This constructor of an object of type 'X' has not returned when the virtual method was called}}
     // expected-note-re@-4 {{{{^}}Call to virtual function during construction}}
 #endif
   }
   X(int i) {
     if (i > 0) {
 #if !PUREONLY
-  // expected-note-re@-2 {{{{^}}Taking true branch}}
-  // expected-note-re@-3 {{{{^}}Taking false branch}}
+        // expected-note-re@-2 {{{{^}}Assuming 'i' is > 0}}
+  // expected-note-re@-3 {{{{^}}Taking true branch}}
+  // expected-note-re@-4 {{{{^}}Assuming 'i' is <= 0}}
+  // expected-note-re@-5 {{{{^}}Taking false branch}}
 #endif
       X x(i - 1);
 #if !PUREONLY
   // expected-note-re@-2 {{{{^}}Calling constructor for 'X'}}
 #endif
       x.g(); // no warning
     }
     g(); 
 #if !PUREONLY
     // expected-warning-re@-2 {{{{^}}Call to virtual function during construction}}