TomasMatousek

user stats

Member SinceJuly 12, 2006
Last VisitSeptember 18, 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

September 25, 2014 - .NET Compiler Platform ("Roslyn"): Committed 06979fd8cc8f83bdd414ec6d84f0118a039506e7, AssemblyMetadata and ModuleMetadata factories should not read the content of the PE file/metadata blob. Currently the factories read the headers, Assembly and Modules tables, which might result in BadImageFormatException being thrown. This exception is not turned into a compilation diagnostic because it happens before the compilation is created. A user of the Roslyn API thus needs to handle these errors in two places (as an exception and as a diagnostics). The content reading should be deferred until the AssemblyMetadata/ModuleMetadata is queried for content. This change defers metadata/PE headers reading and decoding until the AssemblyMetadata and ModuleMetadata properties/methods are called. For metadata created from files it aims to match the usage pattern of other APIs working with FileStream. The metadata factory opens the file, which might throw IO exception, but doesn't start reading the stream until the compiler asks for it, therefore it doesn't throw BadImageFormatException. The functionality is equivalent to the user opening a FileStream and creating metadata from that stream (except for a slight complication with multi-module assemblies, which are rare). Thus the API for metadata creation are consistent among in-memory byte array, stream, and file path. (changeset 1342462)

September 24, 2014 - .NET Compiler Platform ("Roslyn"): Committed fa9663bb2519d7cf327c5374ea5fc7dccf1e0e11, Since addition of expression-bodied methods a method body doesn't need to be a block syntax. Clean up a few places in code-gen and SourceMethodSymbol that seem to not reflect the new reality. Corrects reporting of WRN_ExternMethodNoImplementation - avoid reporting it for expression bodied methods if ERR_ExternHasBody has already been reported (to match behavior of block bodied methods). (changeset 1338919)

September 24, 2014 - .NET Compiler Platform ("Roslyn"): Committed 09110cb1fafba5ea9f84b695dccfc70714d8b9c8, Misc minor renames and refactorings. (changeset 1338075)

September 24, 2014 - .NET Compiler Platform ("Roslyn"): Committed 352e1c9bbc5cc1bd312ef77320d767a6b9ffee94, Removes workarounds for portability bugs 967430 and 797360 - the underlying issues in the project system have been fixed. Removes explicit references to portable facade assemblies (System.IO, System.Runtime, etc.). (changeset 1336570)

September 9, 2014 - .NET Compiler Platform ("Roslyn"): Committed 91ff7bf1d446ef361e3d4f6a1c0a9c22f22e1714, Replace uint method token with MethodHandle in EnC public API. Move some code shareable between C# and VB to MetadataDecoder. (changeset 1321270)

September 9, 2014 - .NET Compiler Platform ("Roslyn"): Committed afbec6e54dcc01ad2c9ee4d4c79999eddf0c7f5c, Refactoring of EnC local mapping to enable mapping fields of state machines in subsequent changesets. Merges FullLocalSlotManager and EncLocalSlotManager into the base class. Instead of subclassing we now delegate the slot allocation implementation to an optional VariableSlotAllocator. If not present, the standard (non-EnC) allocation kicks in. Adds CommonSynthesizedLocalKind enum for synthesized variable kinds that should be shared between VB and C#. Currently VariableSlotAllocator only provides slots for locals. In subsequent changes it will provide slots for state machine fields as well. Hence it is passed into iterator and async rewriters. (changeset 1320562)

September 9, 2014 - .NET Compiler Platform ("Roslyn"): Committed 77dca3d71d4871d7e66e26a55cfcc1ed3ec298d3, EnC: Reuse definitions of synthesized symbols When emitting a compilation difference we calculate a changeset based on the set of user-defined symbols that changed. This changeset is used to filter out methods that don't need to be compiled (they haven't changed). The symbols synthesized during compilation of the user-defined symbols are not known during this phase. Rather than duplicating lowering logic to figure all the set of synthesized symbols that need to be included in the delta we defer this decision till emit time. We compile the user-defined source symbols as usual producing new synthesized symbols. Then when emitting tokens for these symbols we decide what to do with the synthesized symbol based on the method that generated it. (changeset 1319785)

August 14, 2014 - .NET Compiler Platform ("Roslyn"): Committed ad2bd29ce8320b62dccdd0c41a3255e172d41f62, Preparation for hoisting more locals in Debug builds. I noticed we can use less maps while rewriting a method to a class. MethodToClassRewriter: - parameterMap could be moved up to LambdaRewriter since it's only needed when rewriting lambdas. - variablesCaptured is replaced by a virtual NeedsProxy method which is implemented on LambdaRewriter and StateMachineRewriter using existing maps (so we can save another HashSet). We can also distinguish between "captured" variables and variables we create proxy field for. The former are deduced from syntax. A variable may be captured but not lifted into a field (e.g. expression tree lambda parameter). Or a variable can be lifted to field but not captured (in Debug builds we are going to lift user defined variables that are not captured to allow their later capture during EnC). LambdaRewriter: - variablesCaptured encodes the same information as keys of captured syntax multi-dictionary. - declaredInsideExpressionLambda is not needed either. When visiting ET lambdas we used to add their parameters to both variableBlock and declaredInsideExpressionLambda maps. Since ET lambda parameters are never lifted to closure we can avoid adding them to variableBlock map instead of excluding them later via declaredInsideExpressionLambda lookup. Adds internal IReadOnlySet similar to IReadOnlyList and IReadOnlyDictionary so that we can specify an intent of not mutating a set. (changeset 1317999)

August 14, 2014 - .NET Compiler Platform ("Roslyn"): Committed ad2bd29ce8320b62dccdd0c41a3255e172d41f62, Preparation for hoisting more locals in Debug builds. I noticed we can use less maps while rewriting a method to a class. MethodToClassRewriter: - parameterMap could be moved up to LambdaRewriter since it's only needed when rewriting lambdas. - variablesCaptured is replaced by a virtual NeedsProxy method which is implemented on LambdaRewriter and StateMachineRewriter using existing maps (so we can save another HashSet). We can also distinguish between "captured" variables and variables we create proxy field for. The former are deduced from syntax. A variable may be captured but not lifted into a field (e.g. expression tree lambda parameter). Or a variable can be lifted to field but not captured (in Debug builds we are going to lift user defined variables that are not captured to allow their later capture during EnC). LambdaRewriter: - variablesCaptured encodes the same information as keys of captured syntax multi-dictionary. - declaredInsideExpressionLambda is not needed either. When visiting ET lambdas we used to add their parameters to both variableBlock and declaredInsideExpressionLambda maps. Since ET lambda parameters are never lifted to closure we can avoid adding them to variableBlock map instead of excluding them later via declaredInsideExpressionLambda lookup. Adds internal IReadOnlySet similar to IReadOnlyList and IReadOnlyDictionary so that we can specify an intent of not mutating a set. (changeset 1317999)

August 14, 2014 - .NET Compiler Platform ("Roslyn"): Committed 1b2ccf9fcf96441a960daa22ac9e399aba7b2617, Remove unneccessary Import. (changeset 1317910)

projects i'm following

forks

No forks.