C#: Span refinement for Overload Resolution errors. If target is a qualified name, limit span to its right most part. (changeset 1221372)

Reduce the cost of copying large structs (ChildSyntaxList.Enumerator and SyntaxTriviaList.Enumerator) by constructing Enumerators in-place. (changeset 1221230)

Update AnalyzerImageReference to accept an empty array of analyzers, rather than throwing an exception. (changeset 1221162)

Turns out that Asc() and Chr() use different methods to determine current encoding, so Asc(Chr(X)) is not always equal to X.

Tests cannot rely on compositions like Asc(CharW(X)) and AscW(Chr(X)) either - they may return a value different than argument X on a non-ENU system.

The fix is to check what exactly does such function composition return on a particular system, and expect that output.

Had to add a reference to Microsoft.VisualBasic, and fix several variable names to not clash with functions from the library. (changeset 1221000)

Add skipped test for analyzer references in MSBuild workspace and remove some commented code. (changeset 1220801)

Add diagnostics binaries to the list we need to disable strong name verification for. (changeset 1220728)

Simplify build versioning for OSS builders.

Always build delay signed with the MS key, and the RoslynMajorVersion (0.6.0.0).  While this requires disabling strong name verification up-front, it results in many fewer failure modes when trying to deploy changes to VS, as you can't end up with mismatched public key tokens or versions.

Also, removes a lot of complicated build logic from our targets files. (changeset 1220638)

Instead of trying to have emit repeat the checks performed during lowering, just have it consume the results of those checks (i.e. whether or not the string switch helper method was actually synthesized).

VB already had a test documenting that this scenario is unsupported (appropriate errors are reported). (changeset 1220615)

Remove @ in front of C# keyword identifer when pass to dynamic object (changeset 1220579)

* EmitFieldLoadReceiverAddress do not need to dig through fields of reference types. The indirect field access optimization makes sense only in a case of structs. There was a subtle bug here in a case of accessing a field of a nested unboxed struct.
* Volatile fields cannot be nonprimitive valuetypes. Removed dead code in codegen that tried to handle that case.
 (changeset 1220566)

Additional CR feedback on changeset #1215080 - checking the ordinal is slightly faster than recursing on the wrapped parameter. (changeset 1220524)

Proofing FixIncorrectTokenTests against changes in end-of-line characters (0x0D0A to 0x0A) in multi-line verbatim string literals (changeset 1220494)

- For Query Expressions, limit the span to operator(s) token(s).
- For other expressions, exclude arguments from the span. If target is a qualified name, limit span to its right most part. (changeset 1220484)

Bug fix 896727: SuppressMessageAttributeState should suppress syntax diagnostics by walking up the syntax tree from the diagnostic's location calling SemanticModel.GetDeclaredSymbols().  This effectively means that diagnostics will be suppressed if their location is within the full span of one of the declaration nodes of a symbol that has a corresponding SuppressMessageAttribute. The exception to this rule is namespace symbols: only diagnostics on syntax nodes whose inner-most containing symbol is a namespace with a corresponding SuppressMessageAttribute will be suppressed when SuppressMessageAttribute.Scope is "namespace".

+ Added internal SemanticModel.GetDeclaredSymbols() API which behaves the same as SemanticModel.GetDeclaredSymbol() but potentially returns multiple symbols when passed a field declaration.
+ Updated SuppressMessageAttribute test base to use "Diagnostic()" helper method to make use of the output from the VerifyAnalyzerDiagnostics test helper.
+ Added null check for SuppressMessageAttribute.Id: incorrect attribute constructor usage could cause a failure to get its value as a string.
 (changeset 1220357)

1. Removing default parameter in StringTextTests_Default.Create to avoid possible confusion
2. Adding back the check of the fact that DetectEncodingAndDecode picks Windows-1252 (note: this will have to change after https://roslyn.codeplex.com/workitem/17 is fixed (changeset 1220319)

CR feedback on changeset #1215080 - need to handle reduced extension method parameters too. (changeset 1220283)

one of async method call missed ConfigureAwait(false) (changeset 1220131)

our snapshot model used to go back to the end (text) to re-construct everything from scratch in case needed information is kicked out from memory (or cache)

this change makes that layer to be one up to tree rather than text. one reason is deserializing is 2x faster than parsing and second reason is most of work we do relies on tree not text. so once tree is parsed the text we bring back to memory no longer needed until tree gets kicked out from memory again. this should cut the middle man and let us go straight to tree.

text will be still snapshoted to temporary storage, but once initial parsing is done right after solution load, it will be rarely brought into memory again unless a feature explicitly needs text to do some operation.

here is some perf information between parsing/serialization/deserialization.

...

[11412] *** RUN : 1
[11412] vbsource : 2556 files, size : 56979199 chars (it is unicode so 2 bytes per 1 char)
[11412] cssource : 6465 files, size : 54516545 chars

[11412] *** Iteration : 0
[11412] vb parsed : 2556, time took : 34329ms, size : 56979199 chars (same here)
[11412] cs parsed : 6465, time took : 24430ms, size : 54516545 chars

[11412] vb serialzied : 2556, time took : 20959ms, size : 69724370 bytes (length of stream)
[11412] cs serialzied : 6465, time took : 20917ms, size : 59704755 bytes

[11412] vb deserialzied : 2556, time took : 15616ms, size : 56979199 chars
[11412] cs deserialzied : 6465, time took : 14912ms, size : 54516545 chars

...

as a follow up change, I will re-adjust some of our default cache values.
 (changeset 1219990)

Ported to VB the change that makes file reads in command line compiler asyncronous. (changeset 1219674)

Fixed StringTextTests_Default.GetTextDiacritic by explicitly specifying Windows-1252 encoding. Previously test depended on the fact that Windows-1252 was the default system encoding. Now that this fact is mimicked by DetectEncodingAndDecode, we specify code page 1252 explicitly in the test. This test will have to be modified accordingly, once the issue https://roslyn.codeplex.com/workitem/17 with DetectEncodingAndDecode is fixed (changeset 1219658)

Splitting test EncodedStringTextTests.Decode into Decode_Utf8() and Decode_NonUtf8(). Previously Decode test checked two things:
1. The fact that UTF8-decoding of Windows-1252-encoded international text will fail
2. The fact that Windows-1252 encoding would be auto-detected for a Windows-1252-encoded text

When user changed default system locale, #2 failed, as there is no reliable way to discern Windows-1252 encoding from other single-byte full-ASCII encodings.

The fix is to separate #1 into a separate Decode_NonUtf8 test, and check auto-detection of UTF-8 encoding instead in a new Decode_Utf8 test, which should work reliably regardless of current system locale (changeset 1219648)

This is a minimal fix for tests VisualBasic.UnitTests.CommandLineTests.BinaryFile and CSharp.UnitTests.CommandLineTests.BinaryFileErrorTest and the issue that they surface.

We have a heuristic in EncodedStringText.DecodeIfNotBinary() that checks if a non-UTF8-encoded source file passed as argument for command line compiler is a binary file, and quickly fails decoding in this case. However, this heuristic only ran in case system default encoding was Windows-1252.

The perfect fix would be to extend DecodeIfNotBinary, to apply heuristic for any possible encoding, but this requires substantial changes to support multi-byte encodings (Windows-1252 is a single-byte one, so a read buffer can be decoded on each Stream.Read).

But I'll leave the correct fix till after Build, meanwhile making the most isolated change that would fix the tests and apply heuristic to binary files under any system locale, which would be to default to Windows-1252 for any non-UTF8 source file, if the user has not specified code page explicitly. (changeset 1219639)

Eliminated the StrongBox-es in favor of hand-rolled stacks of value-types.
Eliminated the UnionStack`2 and UnionStack`3 types.
Introduced dedicated methods on ChildSyntaxList.Enumerator for combining "MoveNext" and "Current" into one method call. (changeset 1219622)

These tests verify that in absence of /utf8output option, command line compilers use default system encoding for error messages. Previously, they verified that a Cyrillic characters appeared in command line compiler error message as "???". However, when system locale was set to Russian, Cyrillic characters appeared as is, which broke the tests.

Picking a character that is not mapped under any of the default system locale choices (such as chess black king character U+265A) makes these tests independent of current system locale.
 (changeset 1219594)

changed VersionStamp.Default to default(VersionStamp) rather than new VersionStamp(default(DateTime)) (changeset 1219461)

MSBuild was passing in the main parameter quoted in certain circumstances. (use of Cyrillic with Rootnamespace and MainTypeName).   Issue would not manifest itself from the command line (rvbc/rcsc) but was identified when using MSBuild/Visual Studio.    Problem was traced to MSBuild returning the command line argument for main switch when cyrillic namespace was used resulting in the value being quoted.   English namespaces did not cause value to be quoted.

 (changeset 1219429)

The ultimate goal is to merge MetadataReferenceProvider and MetadataReferenceResolver. This is the first step in that direction.

Make TouchedFileLogger internal and move it to CommandLine folder. Remove the logger from the public resolvers. Implement customized resolvers for command line compilers that do the logging.
Move all methods participating in reference/analyzer resolving in command line compiler to CommandLineArguments and clean up the implementation.
Make sure that search paths stored on CommandLineArguments are normalized. (changeset 1219290)

Remove Cci.IResource and Cci.IResourceReference types and move ManagedResource class to Microsoft.Cci namespace -- the type doesn't depend on symbols, the indirection thru interfaces is unnecessary.
Rename AliasForType<T> to TypeExport<T> and move it to Emit namespace -- the type depends on symbols.
Delete unused code and useless comments on internal types. (changeset 1219205)

GetSpeculativeSymbolInfo for Cref in C# was not used in the Simplifier Engine. This change adds the ability to reduce CrefSyntax in C#

For Eg:
1. ClassFoo.MethodBar() reduces to MethodBar()
2. NamespaceBaz.ClassFoo reduces to ClassFoo

as long the semantic meaning holds after the reduction as well. (changeset 1219194)

     This empty interface type helps us mark services that will be implemented by language specific
     implementations.  However, due to it being internal, it can only be implemented by services in
     the same assembly, or in assemblies that have InternalsVisibleTo access to it.  This relaxes that
     restriction, removing another need for InternalsVisibleTo. (changeset 1218469)

     Previous implementation used parallel for + syncronous IO. The disadvantages were that if we would need to actually read from disk, the corresponding thread would block.
     We might still make progress parsing other files on other threads, but if we are "unlucky" we may need to wait until thread pool expands.

     New solution attempts to schedule file reads for all sources at once and corresponding parsing happens in continuations. We should be making progress as soon as we read any of the files.
     There are disadvantages here too:
     1) it is a more complicated approach with several tasks/continuations created per source file.  (parallel for partitioning is much more frugal with tasks - it handles multiple source files per task, though sequentially )
     2) async approach causes the main thread to always block on WaitAll while parallel for manages to keep the main thread busy.
     3) async approach tend to start with "easy" files that happen to be read quicker. Thus there is a higher potential for everything to be waiting for one large file to be parsed at the end.

Overall, I do not see much difference in project build throughput on my machine, but it may benefit cold/buildlab scenarios.
We need to run this on a wider range of senarios and hardware to see the overal impact of the change.
 (changeset 1218376)

- remove old source control properties
- include assets in source.extension.vsixmanifest files. (changeset 1218129)

  Improved Diagnostic handling for VB Core missing functionality.  For "My" functionality and other types missing runtime helpers which result in missingruntime diagnostic when using late binding, old style error handling, err object and like operator on platforms utilizing VBCore.

     Recent Connect Bug has identified the issue again.
     https://connectadmin/Feedback/ConnectTab.aspx?FeedbackID=826578

     But these diagnostics have been something which was identified in initial implementation of VBCore but time constraints and priorities meant it wasn't addressed.
 (changeset 1217985)