TomasMatousek

user stats

Member SinceJuly 12, 2006
Last VisitJuly 24, 2014

Contact

coordinator for

IronRuby
MySQL Extensions for Phalanger

developer for

.NET Compiler Platform ("Roslyn")

TomasMatousek

personal statement

No personal statement has been written.

activity stream

July 23, 2014 - .NET Compiler Platform ("Roslyn"): Committed a05aeec0392fea50ecbd2ccf3eea3afeeb661a57, Fixes sequence points for infinite for loop: for(;;) {}. We used to create a sequence point that spans over the entire ForStatement node. Instead this sequence point should be hidden, there is no user code in for (;;) so we don't step on it. Fixes EnC active statement mapping for parts of ForStatement - initialization/declaration, condition and incrementing expressions are now considered significant nodes in statement tree. (changeset 1303974)

July 22, 2014 - .NET Compiler Platform ("Roslyn"): Committed 53d9e2c14ad40477a5c25c6c978020f9e15f8904, Better organize PDB tests. (changeset 1303214)

July 21, 2014 - .NET Compiler Platform ("Roslyn"): Committed 56ecb0afc5d35df348336979457abc2ea1c3a834, Fix typo. (changeset 1301710)

July 17, 2014 - .NET Compiler Platform ("Roslyn"): Committed b0615ac85d5ffa6e91b2aed11888f74c930a0c9d, Adjusting conditional branches for EnC. For every conditional branch that consumes a value of an expression that might contain calls to user code and that jumps across user code with sequence points, we need to store the value into a synthesized named local, emit stloc and ldloc and place a hidden sequence point on the ldloc instruction. Furthermore, the synthesized local variable has to be associated with the statement syntax whose lowering produces the conditional branch so that EnC infrastructure can map the local variable defined for the branch to the previous generation. In essence this is what’s going on: [|if (F())|] { … true … } else { … false … } IL: call F() stloc $value <-- hidden sequence point --> ldloc $value brfalse label_false <-- sequence point for “{“ of true-block --> … true … br label_end label_false: <-- sequence point for “{“of false-block --> … false … label_end: When the call to F() returns after an update has been performed on the caller the code execution continues in the old version of the caller body until a special remapping breakpoint is hit. These breakpoints are put on all sequence points of the method. If we didn’t put the hidden sequence point in front of the conditional branch the execution would continue in the old code until another sequence point is hit. Such a sequence point can be arbitrary (suppose e.g. that the else block of the if statement is deleted by an edit). The debugger only knows how to map IP of active statements in the old IL to an IP in the new IL, not arbitrary sequence points. By inserting the hidden sequence point we force the mapping to be performed at well-defined point that we can map to the new method body. The presence of the hidden sequence point then implies the need of storing the value of the if-statement condition to a long-lived local and reloading it back right after the sequence point. The store will happen before the IP is remapped and the load will happen in the new frame. The synthesized local must be allocated the same slot in the new frame so that its value is transferred from the old frame to the new frame. Fixes bug 927151: Edit and Continue breaks If statements while inside the conditional method. This change also includes an update to the test infrastructure to 1) make it easier to update failing test that checks for an expected IL If a VerifyIL fails it synthesizes a temp file containing the unit test source and prints out a link that launches a diff tool (using ROSLYN_DIFFTOOL environment variable). 2) to be able to directly test correspondence of sequence points to IL. VerifyIL has now an optional argument “sequencePoints”. When specified the printed IL will contain marks that designate presence of sequence points at IL offsets. “-“ for regular sequence point, “~” for hidden sequence points. I have updated some tests that are supposed to validate correspondence of sequence points to IL instructions to use this new format. (changeset 1299447)

July 12, 2014 - .NET Compiler Platform ("Roslyn"): Posted to discussion: Make reflection easier

July 11, 2014 - .NET Compiler Platform ("Roslyn"): Committed 8bc671b79fc9562d9843b9a22726c348ee4f9712, Misc renames and cleanup (changeset 1293365)

July 11, 2014 - .NET Compiler Platform ("Roslyn"): Committed d4b0a8674529d9e0b9a9cd0c9dabf572a09cebc7, To support EnC well the compiler needs to carefully distinguish between long-lived and short-lived synthesized variables. Long-lived variables may cross sequence points and thus need to be mapped the the corresponding variables in the previous generation when emitting EnC deltas. Short-lived local variables shall never cross sequence points. This change revisits helpers that create synthesized variables and assigns each synthesized variable a SynthesizedLocalKind. Negative kind values are reserved for short-lived variables, positive values for long-lived variables. The change removed the option to give a synthesized variable an explicit name. The names of the variables are assigned at code-gen time based on their SynthesizedLocalKind. This is to enforce that the names of long-lived variables follow a naming pattern that allows use to reverse-engineer the SynthesizedLocalKind value from the variable name. Also renames DebugInformationKind.PDBOnly to DebugInformationKind.PdbOnly to follow .NET naming guidelines. (changeset 1293017)

July 11, 2014 - .NET Compiler Platform ("Roslyn"): Committed 00aa86c730f9e56c16ff001bd99fb5d38f1edf5b, Implements breakpoint spans for expression bodied members. Moves expression bodied members feature out of experimental to C# 6. EnC support for expression bodies and property initializers. The trickiest part was to recognize EnC edit that transforms an expression body to a block body as an allowed update instead of rude body delete and addition. (changeset 1292109)

July 1, 2014 - .NET Compiler Platform ("Roslyn"): Committed 4a80f87fe7e3026f9cfc24cc1e4ebfe92eb1f0fe, This change is a modification of Neal's changeset. It includes all the changes need for moving expression-bodied properties and methods to C# 6, but doesn't do so yet. We need to make sure that the EnC and debugging experience is at least reasonable (non-crashing) first. I'll follow up with a change that updates the EnC logic and flips the switch for these features. (changeset 1289212)

July 1, 2014 - .NET Compiler Platform ("Roslyn"): Committed b7728210850ebc782f81f1a9dfaf0c338a25ba46, Avoid naming local <>t__ex. The compiler generates a local variable to store an exception object in synthesized try-catch handler of an async method. It also used to generate a hidden sequence point in the middle of it's lifespan. This sequence point is unnecessary. Once removed the variable name can also be removed. (changeset 1287817)

projects i'm following

forks

No forks.