From a56b8351a35f8389048bf623b8910637d44ca708 Mon Sep 17 00:00:00 2001
From: Alireza Habibi <habibi.alireza@outlook.com>
Date: Tue, 6 Dec 2016 23:21:00 +0330
Subject: [PATCH 001/284] Clarify error message when this is returned by
 reference

---
 .../Portable/Binder/Binder_Statements.cs      | 10 ++-
 .../Semantics/RefLocalsAndReturnsTests.cs     | 65 +++++++++++--------
 2 files changed, 44 insertions(+), 31 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
index c06786850b85a..3e095c8e05818 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
@@ -1147,8 +1147,6 @@ static private ErrorCode GetThisLvalueError(BindValueKind kind)
                     return ErrorCode.ERR_AddrOnReadOnlyLocal;
                 case BindValueKind.IncrementDecrement:
                     return ErrorCode.ERR_IncrementLvalueExpected;
-                case BindValueKind.RefReturn:
-                    return ErrorCode.ERR_RefReturnStructThis;
             }
         }
 
@@ -1572,9 +1570,15 @@ private bool CheckIsVariable(SyntaxNode node, BoundExpression expr, BindValueKin
             var thisref = expr as BoundThisReference;
             if (thisref != null)
             {
+                if (kind == BindValueKind.RefReturn)
+                {
+                    Error(diagnostics, thisref.Type.IsValueType ? ErrorCode.ERR_RefReturnStructThis : ErrorCode.ERR_RefReadonlyLocal, node, ThisParameterSymbol.SymbolName);
+                    return false;
+                }
+
                 // We will already have given an error for "this" used outside of a constructor, 
                 // instance method, or instance accessor. Assume that "this" is a variable if it is in a struct.
-                if (!thisref.Type.IsValueType || kind == BindValueKind.RefReturn)
+                if (!thisref.Type.IsValueType)
                 {
                     // CONSIDER: the Dev10 name has angle brackets (i.e. "<this>")
                     Error(diagnostics, GetThisLvalueError(kind), node, ThisParameterSymbol.SymbolName);
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/RefLocalsAndReturnsTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/RefLocalsAndReturnsTests.cs
index cabae1fcb9d95..24fb2cb88268c 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/RefLocalsAndReturnsTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/RefLocalsAndReturnsTests.cs
@@ -595,37 +595,46 @@ static ref char Test1()
         }
     }
   
-
+    public class C
+    {
+        public ref C M()
+        {
+            return ref this;
+        }
+    }
 }";
             var comp = CreateCompilationRef(text);
             comp.VerifyDiagnostics(
-    // (10,24): error CS8170: Struct members cannot return 'this' or other instance members by reference
-    //             return ref this;
-    Diagnostic(ErrorCode.ERR_RefReturnStructThis, "this").WithArguments("this").WithLocation(10, 24),
-    // (15,24): error CS8170: Struct members cannot return 'this' or other instance members by reference
-    //             return ref x;
-    Diagnostic(ErrorCode.ERR_RefReturnStructThis, "x").WithArguments("this").WithLocation(15, 24),
-    // (20,24): error CS8170: Struct members cannot return 'this' or other instance members by reference
-    //             return ref this.x;
-    Diagnostic(ErrorCode.ERR_RefReturnStructThis, "this.x").WithArguments("this").WithLocation(20, 24),
-    // (36,32): error CS8168: Cannot return local 'M1' by reference because it is not a ref local
-    //             return ref Foo(ref M1);
-    Diagnostic(ErrorCode.ERR_RefReturnLocal, "M1").WithArguments("M1").WithLocation(36, 32),
-    // (36,24): error CS8164: Cannot return by reference a result of 'Test.Foo<char>(ref char)' because the argument passed to parameter 'arg' cannot be returned by reference
-    //             return ref Foo(ref M1);
-    Diagnostic(ErrorCode.ERR_RefReturnCall, "Foo(ref M1)").WithArguments("Test.Foo<char>(ref char)", "arg").WithLocation(36, 24),
-    // (41,32): error CS8169: Cannot return a member of local 'M2' by reference because it is not a ref local
-    //             return ref Foo(ref M2.x);
-    Diagnostic(ErrorCode.ERR_RefReturnLocal2, "M2").WithArguments("M2").WithLocation(41, 32),
-    // (41,24): error CS8164: Cannot return by reference a result of 'Test.Foo<char>(ref char)' because the argument passed to parameter 'arg' cannot be returned by reference
-    //             return ref Foo(ref M2.x);
-    Diagnostic(ErrorCode.ERR_RefReturnCall, "Foo(ref M2.x)").WithArguments("Test.Foo<char>(ref char)", "arg").WithLocation(41, 24),
-    // (46,32): error CS8168: Cannot return local 'M2' by reference because it is not a ref local
-    //             return ref Foo(ref M2).x;
-    Diagnostic(ErrorCode.ERR_RefReturnLocal, "M2").WithArguments("M2").WithLocation(46, 32),
-    // (46,24): error CS8165: Cannot return by reference a member of result of 'Test.Foo<Test.S1>(ref Test.S1)' because the argument passed to parameter 'arg' cannot be returned by reference
-    //             return ref Foo(ref M2).x;
-    Diagnostic(ErrorCode.ERR_RefReturnCall2, "Foo(ref M2)").WithArguments("Test.Foo<Test.S1>(ref Test.S1)", "arg").WithLocation(46, 24));
+                // (10,24): error CS8170: Struct members cannot return 'this' or other instance members by reference
+                //             return ref this;
+                Diagnostic(ErrorCode.ERR_RefReturnStructThis, "this").WithArguments("this").WithLocation(10, 24),
+                // (15,24): error CS8170: Struct members cannot return 'this' or other instance members by reference
+                //             return ref x;
+                Diagnostic(ErrorCode.ERR_RefReturnStructThis, "x").WithArguments("this").WithLocation(15, 24),
+                // (20,24): error CS8170: Struct members cannot return 'this' or other instance members by reference
+                //             return ref this.x;
+                Diagnostic(ErrorCode.ERR_RefReturnStructThis, "this.x").WithArguments("this").WithLocation(20, 24),
+                // (36,32): error CS8168: Cannot return local 'M1' by reference because it is not a ref local
+                //             return ref Foo(ref M1);
+                Diagnostic(ErrorCode.ERR_RefReturnLocal, "M1").WithArguments("M1").WithLocation(36, 32),
+                // (36,24): error CS8164: Cannot return by reference a result of 'Test.Foo<char>(ref char)' because the argument passed to parameter 'arg' cannot be returned by reference
+                //             return ref Foo(ref M1);
+                Diagnostic(ErrorCode.ERR_RefReturnCall, "Foo(ref M1)").WithArguments("Test.Foo<char>(ref char)", "arg").WithLocation(36, 24),
+                // (41,32): error CS8169: Cannot return a member of local 'M2' by reference because it is not a ref local
+                //             return ref Foo(ref M2.x);
+                Diagnostic(ErrorCode.ERR_RefReturnLocal2, "M2").WithArguments("M2").WithLocation(41, 32),
+                // (41,24): error CS8164: Cannot return by reference a result of 'Test.Foo<char>(ref char)' because the argument passed to parameter 'arg' cannot be returned by reference
+                //             return ref Foo(ref M2.x);
+                Diagnostic(ErrorCode.ERR_RefReturnCall, "Foo(ref M2.x)").WithArguments("Test.Foo<char>(ref char)", "arg").WithLocation(41, 24),
+                // (46,32): error CS8168: Cannot return local 'M2' by reference because it is not a ref local
+                //             return ref Foo(ref M2).x;
+                Diagnostic(ErrorCode.ERR_RefReturnLocal, "M2").WithArguments("M2").WithLocation(46, 32),
+                // (46,24): error CS8165: Cannot return by reference a member of result of 'Test.Foo<Test.S1>(ref Test.S1)' because the argument passed to parameter 'arg' cannot be returned by reference
+                //             return ref Foo(ref M2).x;
+                Diagnostic(ErrorCode.ERR_RefReturnCall2, "Foo(ref M2)").WithArguments("Test.Foo<Test.S1>(ref Test.S1)", "arg").WithLocation(46, 24),
+                // (58,24): error CS1605: Cannot use 'this' as a ref or out value because it is read-only
+                //             return ref this;
+                Diagnostic(ErrorCode.ERR_RefReadonlyLocal, "this").WithArguments("this").WithLocation(58, 24));
         }
 
         [Fact]

From e09ae57e055941efcd5b475439054424384bac72 Mon Sep 17 00:00:00 2001
From: Steve Melia <steve.j.melia@gmail.com>
Date: Mon, 5 Sep 2016 17:01:52 +0100
Subject: [PATCH 002/284] Issue 10428: Formatting of empty loops now respects
 CSharp spacing options

---
 .../Formatting/Rules/SpacingFormattingRule.cs | 36 ++++---
 .../CSharpTest/Formatting/FormattingTests.cs  | 98 ++++++++++++++++++-
 2 files changed, 116 insertions(+), 18 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/Formatting/Rules/SpacingFormattingRule.cs b/src/Workspaces/CSharp/Portable/Formatting/Rules/SpacingFormattingRule.cs
index e69848ebb4bed..44f079743278b 100644
--- a/src/Workspaces/CSharp/Portable/Formatting/Rules/SpacingFormattingRule.cs
+++ b/src/Workspaces/CSharp/Portable/Formatting/Rules/SpacingFormattingRule.cs
@@ -124,26 +124,24 @@ public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previ
                 return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinCastParentheses);
             }
 
-            // For spacing between the parenthesis and the expression inside the control flow expression
-            if (previousKind == SyntaxKind.OpenParenToken && IsControlFlowLikeKeywordStatementKind(previousParentKind))
-            {
-                return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinOtherParentheses);
-            }
-
             // Semicolons in an empty for statement.  i.e.   for(;;)
-            if (previousKind == SyntaxKind.OpenParenToken || previousKind == SyntaxKind.SemicolonToken)
+            if (previousParentKind == SyntaxKind.ForStatement
+                && this.IsEmptyForStatement((ForStatementSyntax)previousToken.Parent))
             {
-                if (previousToken.Parent.Kind() == SyntaxKind.ForStatement)
+                if (currentKind == SyntaxKind.SemicolonToken
+                    && (previousKind != SyntaxKind.SemicolonToken
+                        || optionSet.GetOption<bool>(CSharpFormattingOptions.SpaceBeforeSemicolonsInForStatement)))
                 {
-                    var forStatement = (ForStatementSyntax)previousToken.Parent;
-                    if (forStatement.Initializers.Count == 0 &&
-                        forStatement.Declaration == null &&
-                        forStatement.Condition == null &&
-                        forStatement.Incrementors.Count == 0)
-                    {
-                        return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpaces);
-                    }
+                    return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBeforeSemicolonsInForStatement);
                 }
+
+                return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceAfterSemicolonsInForStatement);
+            }
+
+            // For spacing between the parenthesis and the expression inside the control flow expression
+            if (previousKind == SyntaxKind.OpenParenToken && IsControlFlowLikeKeywordStatementKind(previousParentKind))
+            {
+                return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceWithinOtherParentheses);
             }
 
             if (currentKind == SyntaxKind.CloseParenToken && IsControlFlowLikeKeywordStatementKind(currentParentKind))
@@ -337,6 +335,12 @@ public override void AddSuppressOperations(List<SuppressOperation> list, SyntaxN
             SuppressVariableDeclaration(list, node, optionSet);
         }
 
+        private bool IsEmptyForStatement(ForStatementSyntax forStatement) =>
+            forStatement.Initializers.Count == 0
+            && forStatement.Declaration == null
+            && forStatement.Condition == null
+            && forStatement.Incrementors.Count == 0;
+
         private void SuppressVariableDeclaration(List<SuppressOperation> list, SyntaxNode node, OptionSet optionSet)
         {
             if (node.IsKind(SyntaxKind.FieldDeclaration) || node.IsKind(SyntaxKind.EventDeclaration) ||
diff --git a/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs b/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs
index 94bacf0aa785c..2f9b7012dbaab 100644
--- a/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs
+++ b/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs
@@ -6792,6 +6792,32 @@ public async Task SpacingForForStatementInfiniteLoop()
         {
             var code = @"
 class Program
+{
+    void Main()
+    {
+        for ( ;;)
+        {
+        }
+    }
+}";
+            var expected = @"
+class Program
+{
+    void Main()
+    {
+        for (; ; )
+        {
+        }
+    }
+}";
+            await AssertFormatAsync(expected, code);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
+        public async Task SpacingForForStatementInfiniteLoopWithNoSpaces()
+        {
+            var code = @"
+class Program
 {
     void Main()
     {
@@ -6810,7 +6836,75 @@ void Main()
         }
     }
 }";
-            await AssertFormatAsync(expected, code);
+            var optionSet = new Dictionary<OptionKey, object>
+            {
+                { CSharpFormattingOptions.SpaceAfterSemicolonsInForStatement, false },
+            };
+
+            await AssertFormatAsync(expected, code, changedOptionSet: optionSet);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
+        public async Task SpacingForForStatementInfiniteLoopWithSpacesBefore()
+        {
+            var code = @"
+class Program
+{
+    void Main()
+    {
+        for (;; )
+        {
+        }
+    }
+}";
+            var expected = @"
+class Program
+{
+    void Main()
+    {
+        for ( ; ;)
+        {
+        }
+    }
+}";
+            var optionSet = new Dictionary<OptionKey, object>
+            {
+                { CSharpFormattingOptions.SpaceBeforeSemicolonsInForStatement, true },
+                { CSharpFormattingOptions.SpaceAfterSemicolonsInForStatement, false },
+            };
+
+            await AssertFormatAsync(expected, code, changedOptionSet: optionSet);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
+        public async Task SpacingForForStatementInfiniteLoopWithSpacesBeforeAndAfter()
+        {
+            var code = @"
+class Program
+{
+    void Main()
+    {
+        for (;;)
+        {
+        }
+    }
+}";
+            var expected = @"
+class Program
+{
+    void Main()
+    {
+        for ( ; ; )
+        {
+        }
+    }
+}";
+            var optionSet = new Dictionary<OptionKey, object>
+            {
+                { CSharpFormattingOptions.SpaceBeforeSemicolonsInForStatement, true },
+            };
+
+            await AssertFormatAsync(expected, code, changedOptionSet: optionSet);
         }
 
         [WorkItem(4421, "https://github.com/dotnet/roslyn/issues/4421")]
@@ -7434,7 +7528,7 @@ await AssertFormatBodyAsync(expected, @"
 
         private Task AssertFormatBodyAsync(string expected, string input)
         {
-            Func<string, string> transform = s => 
+            Func<string, string> transform = s =>
             {
                 var lines = s.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
                 for (int i = 0; i < lines.Length; i++)

From 235acb36141b98f5025ff1bf74eec510e1ceae5d Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Tue, 21 Mar 2017 11:55:09 -0700
Subject: [PATCH 003/284] Produce ref assemblies from command-line and msbuild
 (#17558)

* refonly and refout on command-line and msbuild
* corresponding change to Emit API
* Metadata-only assembly use `throw null` bodies
* Can no longer produce netmodule with metadata only
---
 .../Portable/CSharpResources.Designer.cs      |  18 +
 .../CSharp/Portable/CSharpResources.resx      |   6 +
 .../CommandLine/CSharpCommandLineParser.cs    |  38 +-
 .../Portable/Compilation/CSharpCompilation.cs |   2 -
 .../CSharp/Portable/Errors/ErrorCode.cs       |   2 +
 .../Test/CommandLine/CommandLineTests.cs      | 186 +++++++
 .../Test/Emit/Emit/CompilationEmitTests.cs    | 203 ++++++-
 .../Test/Emit/Emit/DeterministicTests.cs      |   4 +-
 .../CSharp/Test/Emit/Emit/ResourceTests.cs    | 506 +++++++++---------
 .../CSharp/Test/Emit/PDB/PDBTests.cs          |   3 +
 .../Core/MSBuildTask/ManagedCompiler.cs       |  15 +
 .../Core/MSBuildTaskTests/CscTests.cs         |  18 +
 .../Core/MSBuildTaskTests/VbcTests.cs         |  18 +
 .../CodeAnalysisResources.Designer.cs         |  27 +
 .../Core/Portable/CodeAnalysisResources.resx  |   9 +
 .../CommandLine/CommonCommandLineArguments.cs |   5 +
 .../Portable/CommandLine/CommonCompiler.cs    | 104 ++--
 .../Core/Portable/Compilation/Compilation.cs  |  78 +++
 .../EditAndContinue/DeltaMetadataWriter.cs    |   2 +-
 .../Portable/PEWriter/FullMetadataWriter.cs   |   8 +-
 .../Core/Portable/PEWriter/MetadataWriter.cs  | 118 ++--
 .../Core/Portable/PEWriter/PeWriter.cs        |  55 +-
 .../Portable/PEWriter/ReferenceIndexer.cs     |   6 +-
 .../Core/Portable/PublicAPI.Unshipped.txt     |   4 +-
 .../VisualBasicCommandLineParser.vb           |  33 +-
 .../Compilation/VisualBasicCompilation.vb     |   2 -
 .../VisualBasic/Portable/Errors/Errors.vb     |   2 +
 .../Portable/VBResources.Designer.vb          |  18 +
 .../VisualBasic/Portable/VBResources.resx     |   6 +
 .../Test/CommandLine/CommandLineTests.vb      | 195 +++++++
 .../Test/Emit/Emit/CompilationEmitTests.vb    | 236 +++++++-
 .../ExpressionCompiler/EvaluationContext.cs   |   6 +-
 .../ExpressionCompilerTestHelpers.cs          |   2 +-
 .../ExpressionCompiler/EvaluationContext.vb   |   6 +-
 .../Utilities/Portable/Assert/AssertEx.cs     |  18 +
 .../Compilation/CompilationExtensions.cs      |   1 +
 .../Compilation/IRuntimeEnvironment.cs        |   1 +
 .../Portable/Metadata/MetadataReaderUtils.cs  | 138 +++++
 38 files changed, 1715 insertions(+), 384 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
index 05f0ae7abe233..6625a2fac4a1f 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
+++ b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
@@ -6766,6 +6766,15 @@ internal static string ERR_NoNamespacePrivate {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot compile net modules when using /refout or /refonly..
+        /// </summary>
+        internal static string ERR_NoNetModuleOutputWhenRefOutOrRefOnly {
+            get {
+                return ResourceManager.GetString("ERR_NoNetModuleOutputWhenRefOutOrRefOnly", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Cannot create an instance of the abstract class or interface &apos;{0}&apos;.
         /// </summary>
@@ -6829,6 +6838,15 @@ internal static string ERR_NoPIANestedType {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Do not use refout when using refonly..
+        /// </summary>
+        internal static string ERR_NoRefOutWhenRefOnly {
+            get {
+                return ResourceManager.GetString("ERR_NoRefOutWhenRefOnly", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to &apos;{0}&apos;: cannot override because &apos;{1}&apos; does not have an overridable set accessor.
         /// </summary>
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index f5ced08a92dff..148e41e166805 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -2288,6 +2288,12 @@ If such a class is used as a base class and if the deriving class defines a dest
   <data name="ERR_Merge_conflict_marker_encountered" xml:space="preserve">
     <value>Merge conflict marker encountered</value>
   </data>
+  <data name="ERR_NoRefOutWhenRefOnly" xml:space="preserve">
+    <value>Do not use refout when using refonly.</value>
+  </data>
+  <data name="ERR_NoNetModuleOutputWhenRefOutOrRefOnly" xml:space="preserve">
+    <value>Cannot compile net modules when using /refout or /refonly.</value>
+  </data>
   <data name="ERR_OvlOperatorExpected" xml:space="preserve">
     <value>Overloadable operator expected</value>
   </data>
diff --git a/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs b/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
index f83230991b3f1..eea38cd266404 100644
--- a/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
+++ b/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
@@ -67,6 +67,8 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
             string outputDirectory = baseDirectory;
             ImmutableArray<KeyValuePair<string, string>> pathMap = ImmutableArray<KeyValuePair<string, string>>.Empty;
             string outputFileName = null;
+            string outputRefFilePath = null;
+            bool metadataOnly = false;
             string documentationPath = null;
             string errorLogPath = null;
             bool parseDocumentationComments = false; //Don't just null check documentationFileName because we want to do this even if the file name is invalid.
@@ -379,6 +381,7 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
                             }
 
                             continue;
+
                         case "out":
                             if (string.IsNullOrWhiteSpace(value))
                             {
@@ -391,6 +394,26 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
 
                             continue;
 
+                        case "refout":
+                            value = RemoveQuotesAndSlashes(value);
+                            if (string.IsNullOrEmpty(value))
+                            {
+                                AddDiagnostic(diagnostics, ErrorCode.ERR_NoFileSpec, arg);
+                            }
+                            else
+                            {
+                                outputRefFilePath = ParseGenericPathToFile(value, diagnostics, baseDirectory);
+                            }
+
+                            continue;
+
+                        case "refonly":
+                            if (value != null)
+                                break;
+
+                            metadataOnly = true;
+                            continue;
+
                         case "t":
                         case "target":
                             if (value == null)
@@ -1141,6 +1164,16 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
                 diagnosticOptions[o.Key] = o.Value;
             }
 
+            if (metadataOnly && outputRefFilePath != null)
+            {
+                AddDiagnostic(diagnostics, diagnosticOptions, ErrorCode.ERR_NoRefOutWhenRefOnly);
+            }
+
+            if (outputKind == OutputKind.NetModule && (metadataOnly || outputRefFilePath != null))
+            {
+                AddDiagnostic(diagnostics, diagnosticOptions, ErrorCode.ERR_NoNetModuleOutputWhenRefOutOrRefOnly);
+            }
+
             if (!IsScriptRunner && !sourceFilesSpecified && (outputKind.IsNetModule() || !resourcesOrModulesSpecified))
             {
                 AddDiagnostic(diagnostics, diagnosticOptions, ErrorCode.WRN_NoSources);
@@ -1257,7 +1290,7 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
 
             var emitOptions = new EmitOptions
             (
-                metadataOnly: false,
+                metadataOnly: metadataOnly,
                 debugInformationFormat: debugInformationFormat,
                 pdbFilePath: null, // to be determined later
                 outputNameOverride: null, // to be determined later
@@ -1282,8 +1315,9 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
                 Utf8Output = utf8output,
                 CompilationName = compilationName,
                 OutputFileName = outputFileName,
+                OutputRefFilePath = outputRefFilePath,
                 PdbPath = pdbPath,
-                EmitPdb = emitPdb,
+                EmitPdb = emitPdb && !metadataOnly,
                 SourceLink = sourceLink,
                 OutputDirectory = outputDirectory,
                 DocumentationPath = documentationPath,
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index f1c43315e2751..c6a3c6f9668f9 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
@@ -2358,8 +2358,6 @@ internal override bool GenerateResourcesAndDocumentationComments(
             DiagnosticBag diagnostics,
             CancellationToken cancellationToken)
         {
-            Debug.Assert(!moduleBuilder.EmitOptions.EmitMetadataOnly);
-
             // Use a temporary bag so we don't have to refilter pre-existing diagnostics.
             var resourceDiagnostics = DiagnosticBag.GetInstance();
 
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index 3036a614c69cd..8788809a58138 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -1461,5 +1461,7 @@ internal enum ErrorCode
         #endregion more stragglers for C# 7
 
         ERR_Merge_conflict_marker_encountered = 8300,
+        ERR_NoRefOutWhenRefOnly = 8301,
+        ERR_NoNetModuleOutputWhenRefOutOrRefOnly = 8302,
     }
 }
\ No newline at end of file
diff --git a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
index 930f4710de55c..d2534145ba37e 100644
--- a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
+++ b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
@@ -2786,6 +2786,34 @@ public void ParseOut()
                 // error CS2005: Missing file specification for '/out:' option
                 Diagnostic(ErrorCode.ERR_NoFileSpec).WithArguments("/out:"));
 
+            parsedArgs = DefaultParse(new[] { @"/refout:", "a.cs" }, baseDirectory);
+            parsedArgs.Errors.Verify(
+                // error CS2005: Missing file specification for '/refout:' option
+                Diagnostic(ErrorCode.ERR_NoFileSpec).WithArguments("/refout:"));
+
+            parsedArgs = DefaultParse(new[] { @"/refout:ref.dll", "/refonly", "a.cs" }, baseDirectory);
+            parsedArgs.Errors.Verify(
+                // error CS8301: Do not use refout when using refonly.
+                Diagnostic(ErrorCode.ERR_NoRefOutWhenRefOnly).WithLocation(1, 1));
+
+            parsedArgs = DefaultParse(new[] { "/refonly:incorrect", "a.cs" }, baseDirectory);
+            parsedArgs.Errors.Verify(
+                // error CS2007: Unrecognized option: '/refonly:incorrect'
+                Diagnostic(ErrorCode.ERR_BadSwitch).WithArguments("/refonly:incorrect").WithLocation(1, 1)
+                );
+
+            parsedArgs = DefaultParse(new[] { @"/refout:ref.dll", "/target:module", "a.cs" }, baseDirectory);
+            parsedArgs.Errors.Verify(
+                // error CS8302: Cannot compile net modules when using /refout or /refonly.
+                Diagnostic(ErrorCode.ERR_NoNetModuleOutputWhenRefOutOrRefOnly).WithLocation(1, 1)
+                );
+
+            parsedArgs = DefaultParse(new[] { @"/refonly", "/target:module", "a.cs" }, baseDirectory);
+            parsedArgs.Errors.Verify(
+                // error CS8302: Cannot compile net modules when using /refout or /refonly.
+                Diagnostic(ErrorCode.ERR_NoNetModuleOutputWhenRefOutOrRefOnly).WithLocation(1, 1)
+                );
+
             // Dev11 reports CS2007: Unrecognized option: '/out'
             parsedArgs = DefaultParse(new[] { @"/out", "a.cs" }, baseDirectory);
             parsedArgs.Errors.Verify(
@@ -8883,6 +8911,164 @@ public void Version()
             }
         }
 
+        [Fact]
+        public void RefOut()
+        {
+            var dir = Temp.CreateDirectory();
+            dir.CreateDirectory("ref");
+
+            var src = dir.CreateFile("a.cs");
+            src.WriteAllText(@"
+class C
+{
+    /// <summary>Main method</summary>
+    public static void Main()
+    {
+        System.Console.Write(""Hello"");
+    }
+}");
+
+            var outWriter = new StringWriter(CultureInfo.InvariantCulture);
+            var csc = new MockCSharpCompiler(null, dir.Path,
+                new[] { "/nologo", "/out:a.exe", "/refout:ref/a.dll", "/doc:doc.xml", "/deterministic", "a.cs" });
+
+            int exitCode = csc.Run(outWriter);
+            Assert.Equal(0, exitCode);
+
+            var exe = Path.Combine(dir.Path, "a.exe");
+            Assert.True(File.Exists(exe));
+
+            MetadataReaderUtils.VerifyPEMetadata(exe,
+                new[] { "TypeDef:<Module>", "TypeDef:C" },
+                new[] { "MethodDef: Void Main()", "MethodDef: Void .ctor()" },
+                new[] { "CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute" }
+                );
+
+            var doc = Path.Combine(dir.Path, "doc.xml");
+            Assert.True(File.Exists(doc));
+
+            var content = File.ReadAllText(doc);
+            var expectedDoc =
+@"<?xml version=""1.0""?>
+<doc>
+    <assembly>
+        <name>a</name>
+    </assembly>
+    <members>
+        <member name=""M:C.Main"">
+            <summary>Main method</summary>
+        </member>
+    </members>
+</doc>";
+            Assert.Equal(expectedDoc, content.Trim());
+
+            var output = ProcessUtilities.RunAndGetOutput(exe, startFolder: dir.Path);
+            Assert.Equal("Hello", output.Trim());
+
+            var refDll = Path.Combine(dir.Path, Path.Combine("ref", "a.dll"));
+            Assert.True(File.Exists(refDll));
+
+            // The types and members that are included needs further refinement.
+            // ReferenceAssemblyAttribute is missing.
+            // See issue https://github.com/dotnet/roslyn/issues/17612
+            MetadataReaderUtils.VerifyPEMetadata(refDll,
+                new[] { "TypeDef:<Module>", "TypeDef:C" },
+                new[] { "MethodDef: Void Main()", "MethodDef: Void .ctor()" },
+                new[] { "CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute" }
+                );
+
+            output = ProcessUtilities.RunAndGetOutput(refDll, startFolder: dir.ToString(), expectedRetCode: -532462766);
+
+            // Clean up temp files
+            CleanupAllGeneratedFiles(dir.Path);
+        }
+
+        [Fact]
+        public void RefOutWithError()
+        {
+            var dir = Temp.CreateDirectory();
+            dir.CreateDirectory("ref");
+
+            var src = dir.CreateFile("a.cs");
+            src.WriteAllText(@"class C { public static void Main() { error(); } }");
+
+            var outWriter = new StringWriter(CultureInfo.InvariantCulture);
+            var csc = new MockCSharpCompiler(null, dir.Path,
+                new[] { "/nologo", "/out:a.dll", "/refout:ref/a.dll", "/deterministic", "a.cs" });
+            int exitCode = csc.Run(outWriter);
+            Assert.Equal(1, exitCode);
+
+            var dll = Path.Combine(dir.Path, "a.dll");
+            Assert.False(File.Exists(dll));
+
+            var refDll = Path.Combine(dir.Path, Path.Combine("ref", "a.dll"));
+            Assert.False(File.Exists(refDll));
+
+            Assert.Equal("a.cs(1,39): error CS0103: The name 'error' does not exist in the current context", outWriter.ToString().Trim());
+
+            // Clean up temp files
+            CleanupAllGeneratedFiles(dir.Path);
+        }
+
+        [Fact]
+        public void RefOnly()
+        {
+            var dir = Temp.CreateDirectory();
+
+            var src = dir.CreateFile("a.cs");
+            src.WriteAllText(@"
+class C
+{
+    /// <summary>Main method</summary>
+    public static void Main()
+    {
+        error(); // semantic error in method body
+    }
+}");
+
+            var outWriter = new StringWriter(CultureInfo.InvariantCulture);
+            var csc = new MockCSharpCompiler(null, dir.Path,
+                new[] { "/nologo", "/out:a.dll", "/refonly", "/debug", "/deterministic", "/doc:doc.xml", "a.cs" });
+            int exitCode = csc.Run(outWriter);
+            Assert.Equal(0, exitCode);
+
+            var refDll = Path.Combine(dir.Path, "a.dll");
+            Assert.True(File.Exists(refDll));
+
+            // The types and members that are included needs further refinement.
+            // ReferenceAssemblyAttribute is missing.
+            // See issue https://github.com/dotnet/roslyn/issues/17612
+            MetadataReaderUtils.VerifyPEMetadata(refDll,
+                new[] { "TypeDef:<Module>", "TypeDef:C" },
+                new[] { "MethodDef: Void Main()", "MethodDef: Void .ctor()" },
+                new[] { "CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute" }
+                );
+
+            var pdb = Path.Combine(dir.Path, "a.pdb");
+            Assert.False(File.Exists(pdb));
+
+            var doc = Path.Combine(dir.Path, "doc.xml");
+            Assert.True(File.Exists(doc));
+
+            var content = File.ReadAllText(doc);
+            var expectedDoc =
+@"<?xml version=""1.0""?>
+<doc>
+    <assembly>
+        <name>a</name>
+    </assembly>
+    <members>
+        <member name=""M:C.Main"">
+            <summary>Main method</summary>
+        </member>
+    </members>
+</doc>";
+            Assert.Equal(expectedDoc, content.Trim());
+
+            // Clean up temp files
+            CleanupAllGeneratedFiles(dir.Path);
+        }
+
         public class QuotedArgumentTests
         {
             private void VerifyQuotedValid<T>(string name, string value, T expected, Func<CSharpCommandLineArguments, T> getValue)
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
index 222d01b278298..bd115c7776b04 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Immutable;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -40,7 +41,7 @@ public void Main()
             EmitResult emitResult;
             using (var output = new MemoryStream())
             {
-                emitResult = compilation.Emit(output, null, null, null);
+                emitResult = compilation.Emit(output, pdbStream: null, xmlDocumentationStream: null, win32Resources: null);
             }
 
             emitResult.Diagnostics.Verify(
@@ -148,7 +149,7 @@ namespace N.Foo;
             EmitResult emitResult;
             using (var output = new MemoryStream())
             {
-                emitResult = comp.Emit(output, null, null, null);
+                emitResult = comp.Emit(output, pdbStream: null, xmlDocumentationStream: null, win32Resources: null);
             }
 
             Assert.False(emitResult.Success);
@@ -236,6 +237,194 @@ public static void Main()
             }
         }
 
+        [Theory]
+        [InlineData("public int M() { return 1; }", "public int M() { return 2; }", true)]
+        [InlineData("public int M() { return 1; }", "public int M() { error(); }", true)]
+        [InlineData("", "private void M() { }", false)] // Should be true. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
+        [InlineData("internal void M() { }", "", false)]
+        [InlineData("public struct S { private int i; }", "public struct S { }", false)]
+        public void RefAssembly_InvariantToSomeChanges(string change1, string change2, bool expectMatch)
+        {
+            string sourceTemplate = @"
+public class C
+{
+    CHANGE
+}
+";
+            string name = GetUniqueName();
+            string source1 = sourceTemplate.Replace("CHANGE", change1);
+            CSharpCompilation comp1 = CreateCompilationWithMscorlib(Parse(source1),
+                options: TestOptions.DebugDll.WithDeterministic(true), assemblyName: name);
+            ImmutableArray<byte> image1 = comp1.EmitToArray(EmitOptions.Default.WithEmitMetadataOnly(true));
+
+            var source2 = sourceTemplate.Replace("CHANGE", change2);
+            Compilation comp2 = CreateCompilationWithMscorlib(Parse(source2),
+                options: TestOptions.DebugDll.WithDeterministic(true), assemblyName: name);
+            ImmutableArray<byte> image2 = comp2.EmitToArray(EmitOptions.Default.WithEmitMetadataOnly(true));
+
+            if (expectMatch)
+            {
+                AssertEx.Equal(image1, image2);
+            }
+            else
+            {
+                AssertEx.NotEqual(image1, image2);
+            }
+        }
+
+        [Theory]
+        [InlineData("public int M() { error(); }", true)]
+        [InlineData("public int M() { error() }", false)] // Should be true. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
+        [InlineData("public Error M() { return null; }", false)] // This may get relaxed. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
+        public void RefAssembly_IgnoresSomeDiagnostics(string change, bool expectSuccess)
+        {
+            string sourceTemplate = @"
+public class C
+{
+    CHANGE
+}
+";
+            string source = sourceTemplate.Replace("CHANGE", change);
+            string name = GetUniqueName();
+            CSharpCompilation comp1 = CreateCompilationWithMscorlib(Parse(source),
+                options: TestOptions.DebugDll.WithDeterministic(true), assemblyName: name);
+
+            using (var output = new MemoryStream())
+            {
+                var emitResult = comp1.Emit(output, options: EmitOptions.Default.WithEmitMetadataOnly(true));
+                Assert.Equal(expectSuccess, emitResult.Success);
+                Assert.Equal(!expectSuccess, emitResult.Diagnostics.Any());
+            }
+        }
+
+        [Fact]
+        public void VerifyRefAssembly()
+        {
+            string source = @"
+public abstract class PublicClass
+{
+    public void PublicMethod() { System.Console.Write(""Hello""); }
+    private void PrivateMethod() { System.Console.Write(""Hello""); }
+    protected void ProtectedMethod() { System.Console.Write(""Hello""); }
+    internal void InternalMethod() { System.Console.Write(""Hello""); }
+    public abstract void AbstractMethod();
+}
+";
+            CSharpCompilation comp = CreateCompilation(source, references: new[] { MscorlibRef },
+                options: TestOptions.DebugDll.WithDeterministic(true));
+
+            var emitRefOnly = EmitOptions.Default.WithEmitMetadataOnly(true);
+
+            var verifier = CompileAndVerify(comp, emitOptions: emitRefOnly, verify: true);
+
+            // verify metadata (types, members, attributes)
+            var image = comp.EmitToImageReference(emitRefOnly);
+            var comp2 = CreateCompilation("", references: new[] { MscorlibRef, image },
+                options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
+            AssemblySymbol assembly = comp2.SourceModule.GetReferencedAssemblySymbols().Last();
+            var members = assembly.GlobalNamespace.GetMembers();
+            AssertEx.SetEqual(members.Select(m => m.ToDisplayString()),
+                new[] { "<Module>", "PublicClass" });
+
+            AssertEx.SetEqual(
+                ((NamedTypeSymbol)assembly.GlobalNamespace.GetMember("PublicClass")).GetMembers()
+                    .Select(m => m.ToTestDisplayString()),
+                new[] { "void PublicClass.PublicMethod()", "void PublicClass.PrivateMethod()",
+                    "void PublicClass.InternalMethod()", "void PublicClass.ProtectedMethod()",
+                    "void PublicClass.AbstractMethod()", "PublicClass..ctor()" });
+
+            AssertEx.SetEqual(assembly.GetAttributes().Select(a => a.AttributeClass.ToTestDisplayString()),
+                new[] { "System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
+                    "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
+                    "System.Diagnostics.DebuggableAttribute" });
+
+            var peImage = comp.EmitToArray(emitRefOnly);
+            MetadataReaderUtils.VerifyMethodBodies(peImage, expectEmptyOrThrowNull: true);
+        }
+        [Fact]
+        public void EmitMetadataOnly_DisallowPdbs()
+        {
+            CSharpCompilation comp = CreateCompilation("", references: new[] { MscorlibRef },
+                options: TestOptions.DebugDll.WithDeterministic(true));
+
+            using (var output = new MemoryStream())
+            using (var pdbOutput = new MemoryStream())
+            {
+                Assert.Throws<ArgumentException>(() => comp.Emit(output, pdbOutput,
+                    options: EmitOptions.Default.WithEmitMetadataOnly(true)));
+            }
+        }
+
+        [Fact]
+        public void EmitMetadataOnly_DisallowMetadataPeStream()
+        {
+            CSharpCompilation comp = CreateCompilation("", references: new[] { MscorlibRef },
+                options: TestOptions.DebugDll.WithDeterministic(true));
+
+            using (var output = new MemoryStream())
+            using (var metadataPeOutput = new MemoryStream())
+            {
+                Assert.Throws<ArgumentException>(() => comp.Emit(output, metadataPeStream: metadataPeOutput,
+                    options: EmitOptions.Default.WithEmitMetadataOnly(true)));
+            }
+        }
+
+        [Fact]
+        public void EmitMetadata_DisallowOutputtingNetModule()
+        {
+            CSharpCompilation comp = CreateCompilation("", references: new[] { MscorlibRef },
+                options: TestOptions.DebugDll.WithDeterministic(true).WithOutputKind(OutputKind.NetModule));
+
+            using (var output = new MemoryStream())
+            using (var metadataPeOutput = new MemoryStream())
+            {
+                Assert.Throws<ArgumentException>(() => comp.Emit(output, metadataPeStream: metadataPeOutput,
+                    options: EmitOptions.Default));
+            }
+        }
+
+        [Fact]
+        public void EmitMetadataOnly_DisallowOutputtingNetModule()
+        {
+            CSharpCompilation comp = CreateCompilation("", references: new[] { MscorlibRef },
+                options: TestOptions.DebugDll.WithDeterministic(true).WithOutputKind(OutputKind.NetModule));
+
+            using (var output = new MemoryStream())
+            {
+                Assert.Throws<ArgumentException>(() => comp.Emit(output,
+                    options: EmitOptions.Default.WithEmitMetadataOnly(true)));
+            }
+        }
+
+        [Fact]
+        public void EmitMetadata()
+        {
+            string source = @"
+public abstract class PublicClass
+{
+    public void PublicMethod() { System.Console.Write(""Hello""); }
+}
+";
+            CSharpCompilation comp = CreateCompilation(source, references: new[] { MscorlibRef },
+                options: TestOptions.DebugDll.WithDeterministic(true));
+
+            using (var output = new MemoryStream())
+            using (var pdbOutput = new MemoryStream())
+            using (var metadataOutput = new MemoryStream())
+            {
+                var result = comp.Emit(output, pdbOutput, metadataPeStream: metadataOutput);
+                Assert.True(result.Success);
+                Assert.NotEqual(0, output.Position);
+                Assert.NotEqual(0, pdbOutput.Position);
+                Assert.NotEqual(0, metadataOutput.Position);
+                MetadataReaderUtils.VerifyMethodBodies(ImmutableArray.CreateRange(output.GetBuffer()), expectEmptyOrThrowNull: false);
+                MetadataReaderUtils.VerifyMethodBodies(ImmutableArray.CreateRange(metadataOutput.GetBuffer()), expectEmptyOrThrowNull: true);
+            }
+
+            var peImage = comp.EmitToArray();
+            MetadataReaderUtils.VerifyMethodBodies(peImage, expectEmptyOrThrowNull: false);
+        }
+
         /// <summary>
         /// Check that when we emit metadata only, we include metadata for
         /// compiler generate methods (e.g. the ones for implicit interface
@@ -939,7 +1128,7 @@ public class Test
             EmitResult emitResult;
             using (var output = new MemoryStream())
             {
-                emitResult = compilation.Emit(output, null, null, null);
+                emitResult = compilation.Emit(output, pdbStream: null, xmlDocumentationStream: null, win32Resources: null);
             }
 
             Assert.False(emitResult.Success);
@@ -972,7 +1161,7 @@ public static void Main()
             EmitResult emitResult;
             using (var output = new MemoryStream())
             {
-                emitResult = compilation.Emit(output, null, null, null);
+                emitResult = compilation.Emit(output, pdbStream: null, xmlDocumentationStream: null, win32Resources: null);
             }
 
             Assert.True(emitResult.Success);
@@ -1010,7 +1199,7 @@ public static void Main()
             EmitResult emitResult;
             using (var output = new MemoryStream())
             {
-                emitResult = compilation.Emit(output, null, null, null);
+                emitResult = compilation.Emit(output, pdbStream: null, xmlDocumentationStream: null, win32Resources: null);
             }
 
             Assert.True(emitResult.Success);
@@ -2726,7 +2915,7 @@ public void BrokenPDBStream()
             var output = new MemoryStream();
             var pdb = new BrokenStream();
             pdb.BreakHow = BrokenStream.BreakHowType.ThrowOnSetLength;
-            var result = compilation.Emit(output, pdb);
+            var result = compilation.Emit(output, pdbStream: pdb);
 
             // error CS0041: Unexpected error writing debug information -- 'Exception from HRESULT: 0x806D0004'
             var err = result.Diagnostics.Single();
@@ -2737,7 +2926,7 @@ public void BrokenPDBStream()
             Assert.Equal(ioExceptionMessage, (string)err.Arguments[0]);
 
             pdb.Dispose();
-            result = compilation.Emit(output, pdb);
+            result = compilation.Emit(output, pdbStream: pdb);
 
             // error CS0041: Unexpected error writing debug information -- 'Exception from HRESULT: 0x806D0004'
             err = result.Diagnostics.Single();
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/DeterministicTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/DeterministicTests.cs
index 7af8a4edd7fee..12c92566cb4d3 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/DeterministicTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/DeterministicTests.cs
@@ -66,8 +66,8 @@ public void BanVersionWildcards()
                 references: new[] { MscorlibRef },
                 options: TestOptions.DebugDll.WithDeterministic(false));
 
-            var resultDeterministic = compilationDeterministic.Emit(Stream.Null, Stream.Null);
-            var resultNonDeterministic = compilationNonDeterministic.Emit(Stream.Null, Stream.Null);
+            var resultDeterministic = compilationDeterministic.Emit(Stream.Null, pdbStream: Stream.Null);
+            var resultNonDeterministic = compilationNonDeterministic.Emit(Stream.Null, pdbStream: Stream.Null);
 
             Assert.False(resultDeterministic.Success);
             Assert.True(resultNonDeterministic.Success);
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/ResourceTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/ResourceTests.cs
index dc95a75b61541..a416a2b5979c8 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/ResourceTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/ResourceTests.cs
@@ -432,323 +432,321 @@ public void AddManagedResource()
 
             c1 = null;
         }
+
         [Fact]
 
         public void AddResourceToModule()
         {
-            for (int metadataOnlyIfNonzero = 0; metadataOnlyIfNonzero < 2; metadataOnlyIfNonzero++)
-            {
-                var metadataOnly = metadataOnlyIfNonzero != 0;
-                Func<Compilation, Stream, ResourceDescription[], CodeAnalysis.Emit.EmitResult> emit;
-                emit = (c, s, r) => c.Emit(s, manifestResources: r, options: new EmitOptions(metadataOnly: metadataOnly));
+            bool metadataOnly = false;
+            Func<Compilation, Stream, ResourceDescription[], CodeAnalysis.Emit.EmitResult> emit;
+            emit = (c, s, r) => c.Emit(s, manifestResources: r, options: new EmitOptions(metadataOnly: metadataOnly));
 
-                var sourceTree = SyntaxFactory.ParseSyntaxTree("");
+            var sourceTree = SyntaxFactory.ParseSyntaxTree("");
 
-                // Do not name the compilation, a unique guid is used as a name by default. It prevents conflicts with other assemblies loaded via Assembly.ReflectionOnlyLoad.
-                var c1 = CSharpCompilation.Create(
-                    Guid.NewGuid().ToString(),
-                    new[] { sourceTree },
-                    new[] { MscorlibRef },
-                    TestOptions.ReleaseModule);
+            // Do not name the compilation, a unique guid is used as a name by default. It prevents conflicts with other assemblies loaded via Assembly.ReflectionOnlyLoad.
+            var c1 = CSharpCompilation.Create(
+                Guid.NewGuid().ToString(),
+                new[] { sourceTree },
+                new[] { MscorlibRef },
+                TestOptions.ReleaseModule);
 
-                var resourceFileName = "RoslynResourceFile.foo";
-                var output = new MemoryStream();
+            var resourceFileName = "RoslynResourceFile.foo";
+            var output = new MemoryStream();
 
-                const string r1Name = "some.dotted.NAME";
-                const string r2Name = "another.DoTtEd.NAME";
+            const string r1Name = "some.dotted.NAME";
+            const string r2Name = "another.DoTtEd.NAME";
 
-                var arrayOfEmbeddedData = new byte[] { 1, 2, 3, 4, 5 };
-                var resourceFileData = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+            var arrayOfEmbeddedData = new byte[] { 1, 2, 3, 4, 5 };
+            var resourceFileData = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
 
-                var result = emit(c1, output,
-                    new ResourceDescription[]
-                    {
-                        new ResourceDescription(r1Name, () => new MemoryStream(arrayOfEmbeddedData), true),
-                        new ResourceDescription(r2Name, resourceFileName, () => new MemoryStream(resourceFileData), false)
-                    });
+            var result = emit(c1, output,
+                new ResourceDescription[]
+                {
+                    new ResourceDescription(r1Name, () => new MemoryStream(arrayOfEmbeddedData), true),
+                    new ResourceDescription(r2Name, resourceFileName, () => new MemoryStream(resourceFileData), false)
+                });
 
-                Assert.False(result.Success);
-                Assert.NotEmpty(result.Diagnostics.Where(x => x.Code == (int)ErrorCode.ERR_CantRefResource));
+            Assert.False(result.Success);
+            Assert.NotEmpty(result.Diagnostics.Where(x => x.Code == (int)ErrorCode.ERR_CantRefResource));
 
-                result = emit(c1, output,
-                    new ResourceDescription[]
-                    {
-                        new ResourceDescription(r2Name, resourceFileName, () => new MemoryStream(resourceFileData), false),
-                        new ResourceDescription(r1Name, () => new MemoryStream(arrayOfEmbeddedData), true)
-                    });
+            result = emit(c1, output,
+                new ResourceDescription[]
+                {
+                    new ResourceDescription(r2Name, resourceFileName, () => new MemoryStream(resourceFileData), false),
+                    new ResourceDescription(r1Name, () => new MemoryStream(arrayOfEmbeddedData), true)
+                });
 
-                Assert.False(result.Success);
-                Assert.NotEmpty(result.Diagnostics.Where(x => x.Code == (int)ErrorCode.ERR_CantRefResource));
+            Assert.False(result.Success);
+            Assert.NotEmpty(result.Diagnostics.Where(x => x.Code == (int)ErrorCode.ERR_CantRefResource));
 
-                result = emit(c1, output,
-                    new ResourceDescription[]
-                    {
-                        new ResourceDescription(r2Name, resourceFileName, () => new MemoryStream(resourceFileData), false)
-                    });
+            result = emit(c1, output,
+                new ResourceDescription[]
+                {
+                    new ResourceDescription(r2Name, resourceFileName, () => new MemoryStream(resourceFileData), false)
+                });
 
-                Assert.False(result.Success);
-                Assert.NotEmpty(result.Diagnostics.Where(x => x.Code == (int)ErrorCode.ERR_CantRefResource));
+            Assert.False(result.Success);
+            Assert.NotEmpty(result.Diagnostics.Where(x => x.Code == (int)ErrorCode.ERR_CantRefResource));
 
-                var c_mod1 = CSharpCompilation.Create(
-                    Guid.NewGuid().ToString(),
-                    new[] { sourceTree },
-                    new[] { MscorlibRef },
-                    TestOptions.ReleaseModule);
+            var c_mod1 = CSharpCompilation.Create(
+                Guid.NewGuid().ToString(),
+                new[] { sourceTree },
+                new[] { MscorlibRef },
+                TestOptions.ReleaseModule);
 
-                var output_mod1 = new MemoryStream();
-                result = emit(c_mod1, output_mod1,
-                    new ResourceDescription[]
-                    {
-                        new ResourceDescription(r1Name, () => new MemoryStream(arrayOfEmbeddedData), true)
-                    });
+            var output_mod1 = new MemoryStream();
+            result = emit(c_mod1, output_mod1,
+                new ResourceDescription[]
+                {
+                    new ResourceDescription(r1Name, () => new MemoryStream(arrayOfEmbeddedData), true)
+                });
 
-                Assert.True(result.Success);
-                var mod1 = ModuleMetadata.CreateFromImage(output_mod1.ToImmutable());
-                var ref_mod1 = mod1.GetReference();
-                Assert.Equal(ManifestResourceAttributes.Public, mod1.Module.GetEmbeddedResourcesOrThrow()[0].Attributes);
+            Assert.True(result.Success);
+            var mod1 = ModuleMetadata.CreateFromImage(output_mod1.ToImmutable());
+            var ref_mod1 = mod1.GetReference();
+            Assert.Equal(ManifestResourceAttributes.Public, mod1.Module.GetEmbeddedResourcesOrThrow()[0].Attributes);
 
-                {
-                    var c2 = CreateCompilationWithMscorlib(sourceTree, new[] { ref_mod1 }, TestOptions.ReleaseDll);
-                    var output2 = new MemoryStream();
-                    var result2 = c2.Emit(output2);
+            {
+                var c2 = CreateCompilationWithMscorlib(sourceTree, new[] { ref_mod1 }, TestOptions.ReleaseDll);
+                var output2 = new MemoryStream();
+                var result2 = c2.Emit(output2);
 
-                    Assert.True(result2.Success);
-                    var assembly = System.Reflection.Assembly.ReflectionOnlyLoad(output2.ToArray());
+                Assert.True(result2.Success);
+                var assembly = System.Reflection.Assembly.ReflectionOnlyLoad(output2.ToArray());
 
-                    assembly.ModuleResolve += (object sender, ResolveEventArgs e) =>
+                assembly.ModuleResolve += (object sender, ResolveEventArgs e) =>
+                {
+                    if (e.Name.Equals(c_mod1.SourceModule.Name))
                     {
-                        if (e.Name.Equals(c_mod1.SourceModule.Name))
-                        {
-                            return assembly.LoadModule(e.Name, output_mod1.ToArray());
-                        }
+                        return assembly.LoadModule(e.Name, output_mod1.ToArray());
+                    }
 
-                        return null;
-                    };
+                    return null;
+                };
 
-                    string[] resourceNames = assembly.GetManifestResourceNames();
-                    Assert.Equal(1, resourceNames.Length);
+                string[] resourceNames = assembly.GetManifestResourceNames();
+                Assert.Equal(1, resourceNames.Length);
 
-                    var rInfo = assembly.GetManifestResourceInfo(r1Name);
-                    Assert.Equal(System.Reflection.ResourceLocation.Embedded, rInfo.ResourceLocation);
-                    Assert.Equal(c_mod1.SourceModule.Name, rInfo.FileName);
+                var rInfo = assembly.GetManifestResourceInfo(r1Name);
+                Assert.Equal(System.Reflection.ResourceLocation.Embedded, rInfo.ResourceLocation);
+                Assert.Equal(c_mod1.SourceModule.Name, rInfo.FileName);
 
-                    var rData = assembly.GetManifestResourceStream(r1Name);
-                    var rBytes = new byte[rData.Length];
-                    rData.Read(rBytes, 0, (int)rData.Length);
-                    Assert.Equal(arrayOfEmbeddedData, rBytes);
-                }
+                var rData = assembly.GetManifestResourceStream(r1Name);
+                var rBytes = new byte[rData.Length];
+                rData.Read(rBytes, 0, (int)rData.Length);
+                Assert.Equal(arrayOfEmbeddedData, rBytes);
+            }
 
-                var c_mod2 = CSharpCompilation.Create(
-                    Guid.NewGuid().ToString(),
-                    new[] { sourceTree },
-                    new[] { MscorlibRef },
-                    TestOptions.ReleaseModule);
+            var c_mod2 = CSharpCompilation.Create(
+                Guid.NewGuid().ToString(),
+                new[] { sourceTree },
+                new[] { MscorlibRef },
+                TestOptions.ReleaseModule);
 
-                var output_mod2 = new MemoryStream();
-                result = emit(c_mod2, output_mod2,
-                    new ResourceDescription[]
-                    {
-                        new ResourceDescription(r1Name, () => new MemoryStream(arrayOfEmbeddedData), true),
-                        new ResourceDescription(r2Name, () => new MemoryStream(resourceFileData), true)
-                    });
+            var output_mod2 = new MemoryStream();
+            result = emit(c_mod2, output_mod2,
+                new ResourceDescription[]
+                {
+                    new ResourceDescription(r1Name, () => new MemoryStream(arrayOfEmbeddedData), true),
+                    new ResourceDescription(r2Name, () => new MemoryStream(resourceFileData), true)
+                });
 
-                Assert.True(result.Success);
-                var ref_mod2 = ModuleMetadata.CreateFromImage(output_mod2.ToImmutable()).GetReference();
+            Assert.True(result.Success);
+            var ref_mod2 = ModuleMetadata.CreateFromImage(output_mod2.ToImmutable()).GetReference();
 
-                {
-                    var c3 = CreateCompilationWithMscorlib(sourceTree, new[] { ref_mod2 }, TestOptions.ReleaseDll);
-                    var output3 = new MemoryStream();
-                    var result3 = c3.Emit(output3);
+            {
+                var c3 = CreateCompilationWithMscorlib(sourceTree, new[] { ref_mod2 }, TestOptions.ReleaseDll);
+                var output3 = new MemoryStream();
+                var result3 = c3.Emit(output3);
 
-                    Assert.True(result3.Success);
-                    var assembly = Assembly.ReflectionOnlyLoad(output3.ToArray());
+                Assert.True(result3.Success);
+                var assembly = Assembly.ReflectionOnlyLoad(output3.ToArray());
 
-                    assembly.ModuleResolve += (object sender, ResolveEventArgs e) =>
+                assembly.ModuleResolve += (object sender, ResolveEventArgs e) =>
+                {
+                    if (e.Name.Equals(c_mod2.SourceModule.Name))
                     {
-                        if (e.Name.Equals(c_mod2.SourceModule.Name))
-                        {
-                            return assembly.LoadModule(e.Name, output_mod2.ToArray());
-                        }
-
-                        return null;
-                    };
-
-                    string[] resourceNames = assembly.GetManifestResourceNames();
-                    Assert.Equal(2, resourceNames.Length);
-
-                    var rInfo = assembly.GetManifestResourceInfo(r1Name);
-                    Assert.Equal(ResourceLocation.Embedded, rInfo.ResourceLocation);
-                    Assert.Equal(c_mod2.SourceModule.Name, rInfo.FileName);
-
-                    var rData = assembly.GetManifestResourceStream(r1Name);
-                    var rBytes = new byte[rData.Length];
-                    rData.Read(rBytes, 0, (int)rData.Length);
-                    Assert.Equal(arrayOfEmbeddedData, rBytes);
-
-                    rInfo = assembly.GetManifestResourceInfo(r2Name);
-                    Assert.Equal(ResourceLocation.Embedded, rInfo.ResourceLocation);
-                    Assert.Equal(c_mod2.SourceModule.Name, rInfo.FileName);
-
-                    rData = assembly.GetManifestResourceStream(r2Name);
-                    rBytes = new byte[rData.Length];
-                    rData.Read(rBytes, 0, (int)rData.Length);
-                    Assert.Equal(resourceFileData, rBytes);
-                }
+                        return assembly.LoadModule(e.Name, output_mod2.ToArray());
+                    }
 
-                var c_mod3 = CSharpCompilation.Create(
-                    Guid.NewGuid().ToString(),
-                    new[] { sourceTree },
-                    new[] { MscorlibRef },
-                    TestOptions.ReleaseModule);
+                    return null;
+                };
 
-                var output_mod3 = new MemoryStream();
-                result = emit(c_mod3, output_mod3,
-                    new ResourceDescription[]
-                    {
-                        new ResourceDescription(r2Name, () => new MemoryStream(resourceFileData), false)
-                    });
+                string[] resourceNames = assembly.GetManifestResourceNames();
+                Assert.Equal(2, resourceNames.Length);
+
+                var rInfo = assembly.GetManifestResourceInfo(r1Name);
+                Assert.Equal(ResourceLocation.Embedded, rInfo.ResourceLocation);
+                Assert.Equal(c_mod2.SourceModule.Name, rInfo.FileName);
 
-                Assert.True(result.Success);
-                var mod3 = ModuleMetadata.CreateFromImage(output_mod3.ToImmutable());
-                var ref_mod3 = mod3.GetReference();
-                Assert.Equal(ManifestResourceAttributes.Private, mod3.Module.GetEmbeddedResourcesOrThrow()[0].Attributes);
+                var rData = assembly.GetManifestResourceStream(r1Name);
+                var rBytes = new byte[rData.Length];
+                rData.Read(rBytes, 0, (int)rData.Length);
+                Assert.Equal(arrayOfEmbeddedData, rBytes);
 
+                rInfo = assembly.GetManifestResourceInfo(r2Name);
+                Assert.Equal(ResourceLocation.Embedded, rInfo.ResourceLocation);
+                Assert.Equal(c_mod2.SourceModule.Name, rInfo.FileName);
+
+                rData = assembly.GetManifestResourceStream(r2Name);
+                rBytes = new byte[rData.Length];
+                rData.Read(rBytes, 0, (int)rData.Length);
+                Assert.Equal(resourceFileData, rBytes);
+            }
+
+            var c_mod3 = CSharpCompilation.Create(
+                Guid.NewGuid().ToString(),
+                new[] { sourceTree },
+                new[] { MscorlibRef },
+                TestOptions.ReleaseModule);
+
+            var output_mod3 = new MemoryStream();
+            result = emit(c_mod3, output_mod3,
+                new ResourceDescription[]
                 {
-                    var c4 = CreateCompilationWithMscorlib(sourceTree, new[] { ref_mod3 }, TestOptions.ReleaseDll);
-                    var output4 = new MemoryStream();
-                    var result4 = c4.Emit(output4, manifestResources:
-                        new ResourceDescription[]
-                        {
-                            new ResourceDescription(r1Name, () => new MemoryStream(arrayOfEmbeddedData), false)
-                        });
+                    new ResourceDescription(r2Name, () => new MemoryStream(resourceFileData), false)
+                });
 
-                    Assert.True(result4.Success);
-                    var assembly = System.Reflection.Assembly.ReflectionOnlyLoad(output4.ToArray());
+            Assert.True(result.Success);
+            var mod3 = ModuleMetadata.CreateFromImage(output_mod3.ToImmutable());
+            var ref_mod3 = mod3.GetReference();
+            Assert.Equal(ManifestResourceAttributes.Private, mod3.Module.GetEmbeddedResourcesOrThrow()[0].Attributes);
 
-                    assembly.ModuleResolve += (object sender, ResolveEventArgs e) =>
+            {
+                var c4 = CreateCompilationWithMscorlib(sourceTree, new[] { ref_mod3 }, TestOptions.ReleaseDll);
+                var output4 = new MemoryStream();
+                var result4 = c4.Emit(output4, manifestResources:
+                    new ResourceDescription[]
                     {
-                        if (e.Name.Equals(c_mod3.SourceModule.Name))
-                        {
-                            return assembly.LoadModule(e.Name, output_mod3.ToArray());
-                        }
+                        new ResourceDescription(r1Name, () => new MemoryStream(arrayOfEmbeddedData), false)
+                    });
 
-                        return null;
-                    };
+                Assert.True(result4.Success);
+                var assembly = System.Reflection.Assembly.ReflectionOnlyLoad(output4.ToArray());
 
-                    string[] resourceNames = assembly.GetManifestResourceNames();
-                    Assert.Equal(2, resourceNames.Length);
+                assembly.ModuleResolve += (object sender, ResolveEventArgs e) =>
+                {
+                    if (e.Name.Equals(c_mod3.SourceModule.Name))
+                    {
+                        return assembly.LoadModule(e.Name, output_mod3.ToArray());
+                    }
 
-                    var rInfo = assembly.GetManifestResourceInfo(r1Name);
-                    Assert.Equal(ResourceLocation.Embedded | ResourceLocation.ContainedInManifestFile, rInfo.ResourceLocation);
+                    return null;
+                };
 
-                    var rData = assembly.GetManifestResourceStream(r1Name);
-                    var rBytes = new byte[rData.Length];
-                    rData.Read(rBytes, 0, (int)rData.Length);
-                    Assert.Equal(arrayOfEmbeddedData, rBytes);
+                string[] resourceNames = assembly.GetManifestResourceNames();
+                Assert.Equal(2, resourceNames.Length);
 
-                    rInfo = assembly.GetManifestResourceInfo(r2Name);
-                    Assert.Equal(ResourceLocation.Embedded, rInfo.ResourceLocation);
-                    Assert.Equal(c_mod3.SourceModule.Name, rInfo.FileName);
+                var rInfo = assembly.GetManifestResourceInfo(r1Name);
+                Assert.Equal(ResourceLocation.Embedded | ResourceLocation.ContainedInManifestFile, rInfo.ResourceLocation);
 
-                    rData = assembly.GetManifestResourceStream(r2Name);
-                    rBytes = new byte[rData.Length];
-                    rData.Read(rBytes, 0, (int)rData.Length);
-                    Assert.Equal(resourceFileData, rBytes);
-                }
+                var rData = assembly.GetManifestResourceStream(r1Name);
+                var rBytes = new byte[rData.Length];
+                rData.Read(rBytes, 0, (int)rData.Length);
+                Assert.Equal(arrayOfEmbeddedData, rBytes);
 
-                {
-                    var c5 = CreateCompilationWithMscorlib(sourceTree, new[] { ref_mod1, ref_mod3 }, TestOptions.ReleaseDll);
-                    var output5 = new MemoryStream();
-                    var result5 = emit(c5, output5, null);
+                rInfo = assembly.GetManifestResourceInfo(r2Name);
+                Assert.Equal(ResourceLocation.Embedded, rInfo.ResourceLocation);
+                Assert.Equal(c_mod3.SourceModule.Name, rInfo.FileName);
+
+                rData = assembly.GetManifestResourceStream(r2Name);
+                rBytes = new byte[rData.Length];
+                rData.Read(rBytes, 0, (int)rData.Length);
+                Assert.Equal(resourceFileData, rBytes);
+            }
 
-                    Assert.True(result5.Success);
-                    var assembly = Assembly.ReflectionOnlyLoad(output5.ToArray());
+            {
+                var c5 = CreateCompilationWithMscorlib(sourceTree, new[] { ref_mod1, ref_mod3 }, TestOptions.ReleaseDll);
+                var output5 = new MemoryStream();
+                var result5 = emit(c5, output5, null);
 
-                    assembly.ModuleResolve += (object sender, ResolveEventArgs e) =>
-                    {
-                        if (e.Name.Equals(c_mod1.SourceModule.Name))
-                        {
-                            return assembly.LoadModule(e.Name, output_mod1.ToArray());
-                        }
-                        else if (e.Name.Equals(c_mod3.SourceModule.Name))
-                        {
-                            return assembly.LoadModule(e.Name, output_mod3.ToArray());
-                        }
-
-                        return null;
-                    };
-
-                    string[] resourceNames = assembly.GetManifestResourceNames();
-                    Assert.Equal(2, resourceNames.Length);
-
-                    var rInfo = assembly.GetManifestResourceInfo(r1Name);
-                    Assert.Equal(ResourceLocation.Embedded, rInfo.ResourceLocation);
-                    Assert.Equal(c_mod1.SourceModule.Name, rInfo.FileName);
-
-                    var rData = assembly.GetManifestResourceStream(r1Name);
-                    var rBytes = new byte[rData.Length];
-                    rData.Read(rBytes, 0, (int)rData.Length);
-                    Assert.Equal(arrayOfEmbeddedData, rBytes);
-
-                    rInfo = assembly.GetManifestResourceInfo(r2Name);
-                    Assert.Equal(ResourceLocation.Embedded, rInfo.ResourceLocation);
-                    Assert.Equal(c_mod3.SourceModule.Name, rInfo.FileName);
-
-                    rData = assembly.GetManifestResourceStream(r2Name);
-                    rBytes = new byte[rData.Length];
-                    rData.Read(rBytes, 0, (int)rData.Length);
-                    Assert.Equal(resourceFileData, rBytes);
-                }
+                Assert.True(result5.Success);
+                var assembly = Assembly.ReflectionOnlyLoad(output5.ToArray());
 
+                assembly.ModuleResolve += (object sender, ResolveEventArgs e) =>
                 {
-                    var c6 = CreateCompilationWithMscorlib(sourceTree, new[] { ref_mod1, ref_mod2 }, TestOptions.ReleaseDll);
-                    var output6 = new MemoryStream();
-                    var result6 = emit(c6, output6, null);
-
-                    if (metadataOnly)
+                    if (e.Name.Equals(c_mod1.SourceModule.Name))
                     {
-                        Assert.True(result6.Success);
+                        return assembly.LoadModule(e.Name, output_mod1.ToArray());
                     }
-                    else
+                    else if (e.Name.Equals(c_mod3.SourceModule.Name))
                     {
-                        Assert.False(result6.Success);
-                        result6.Diagnostics.Verify(
-                            // error CS1508: Resource identifier 'some.dotted.NAME' has already been used in this assembly
-                            Diagnostic(ErrorCode.ERR_ResourceNotUnique).WithArguments("some.dotted.NAME")
-                            );
+                        return assembly.LoadModule(e.Name, output_mod3.ToArray());
                     }
 
-                    result6 = emit(c6, output6,
-                        new ResourceDescription[]
-                        {
-                            new ResourceDescription(r2Name, () => new MemoryStream(resourceFileData), false)
-                        });
+                    return null;
+                };
 
-                    if (metadataOnly)
-                    {
-                        Assert.True(result6.Success);
-                    }
-                    else
-                    {
-                        Assert.False(result6.Success);
-                        result6.Diagnostics.Verify(
-                            // error CS1508: Resource identifier 'some.dotted.NAME' has already been used in this assembly
-                            Diagnostic(ErrorCode.ERR_ResourceNotUnique).WithArguments("some.dotted.NAME"),
-                            // error CS1508: Resource identifier 'another.DoTtEd.NAME' has already been used in this assembly
-                            Diagnostic(ErrorCode.ERR_ResourceNotUnique).WithArguments("another.DoTtEd.NAME")
-                            );
-                    }
+                string[] resourceNames = assembly.GetManifestResourceNames();
+                Assert.Equal(2, resourceNames.Length);
+
+                var rInfo = assembly.GetManifestResourceInfo(r1Name);
+                Assert.Equal(ResourceLocation.Embedded, rInfo.ResourceLocation);
+                Assert.Equal(c_mod1.SourceModule.Name, rInfo.FileName);
+
+                var rData = assembly.GetManifestResourceStream(r1Name);
+                var rBytes = new byte[rData.Length];
+                rData.Read(rBytes, 0, (int)rData.Length);
+                Assert.Equal(arrayOfEmbeddedData, rBytes);
+
+                rInfo = assembly.GetManifestResourceInfo(r2Name);
+                Assert.Equal(ResourceLocation.Embedded, rInfo.ResourceLocation);
+                Assert.Equal(c_mod3.SourceModule.Name, rInfo.FileName);
+
+                rData = assembly.GetManifestResourceStream(r2Name);
+                rBytes = new byte[rData.Length];
+                rData.Read(rBytes, 0, (int)rData.Length);
+                Assert.Equal(resourceFileData, rBytes);
+            }
 
-                    c6 = CreateCompilationWithMscorlib(sourceTree, new[] { ref_mod1, ref_mod2 }, TestOptions.ReleaseModule);
+            {
+                var c6 = CreateCompilationWithMscorlib(sourceTree, new[] { ref_mod1, ref_mod2 }, TestOptions.ReleaseDll);
+                var output6 = new MemoryStream();
+                var result6 = emit(c6, output6, null);
+
+                if (metadataOnly)
+                {
+                    Assert.True(result6.Success);
+                }
+                else
+                {
+                    Assert.False(result6.Success);
+                    result6.Diagnostics.Verify(
+                        // error CS1508: Resource identifier 'some.dotted.NAME' has already been used in this assembly
+                        Diagnostic(ErrorCode.ERR_ResourceNotUnique).WithArguments("some.dotted.NAME")
+                        );
+                }
 
-                    result6 = emit(c6, output6,
-                        new ResourceDescription[]
-                        {
-                            new ResourceDescription(r2Name, () => new MemoryStream(resourceFileData), false)
-                        });
+                result6 = emit(c6, output6,
+                    new ResourceDescription[]
+                    {
+                        new ResourceDescription(r2Name, () => new MemoryStream(resourceFileData), false)
+                    });
 
+                if (metadataOnly)
+                {
                     Assert.True(result6.Success);
                 }
+                else
+                {
+                    Assert.False(result6.Success);
+                    result6.Diagnostics.Verify(
+                        // error CS1508: Resource identifier 'some.dotted.NAME' has already been used in this assembly
+                        Diagnostic(ErrorCode.ERR_ResourceNotUnique).WithArguments("some.dotted.NAME"),
+                        // error CS1508: Resource identifier 'another.DoTtEd.NAME' has already been used in this assembly
+                        Diagnostic(ErrorCode.ERR_ResourceNotUnique).WithArguments("another.DoTtEd.NAME")
+                        );
+                }
+
+                c6 = CreateCompilationWithMscorlib(sourceTree, new[] { ref_mod1, ref_mod2 }, TestOptions.ReleaseModule);
+
+                result6 = emit(c6, output6,
+                    new ResourceDescription[]
+                    {
+                        new ResourceDescription(r2Name, () => new MemoryStream(resourceFileData), false)
+                    });
+
+                Assert.True(result6.Success);
             }
         }
 
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
index a0fa5bba7f79f..97817fcf5278a 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
@@ -133,6 +133,7 @@ public void SymWriterErrors()
             {
                 var result = compilation.Emit(
                     peStream: peStream,
+                    metadataPeStream: null,
                     pdbStream: pdbStream,
                     xmlDocumentationStream: null,
                     cancellationToken: default(CancellationToken),
@@ -166,6 +167,7 @@ public void SymWriterErrors2()
             {
                 var result = compilation.Emit(
                     peStream: peStream,
+                    metadataPeStream: null,
                     pdbStream: pdbStream,
                     xmlDocumentationStream: null,
                     cancellationToken: default(CancellationToken),
@@ -199,6 +201,7 @@ public void SymWriterErrors3()
             {
                 var result = compilation.Emit(
                     peStream: peStream,
+                    metadataPeStream: null,
                     pdbStream: pdbStream,
                     xmlDocumentationStream: null,
                     cancellationToken: default(CancellationToken),
diff --git a/src/Compilers/Core/MSBuildTask/ManagedCompiler.cs b/src/Compilers/Core/MSBuildTask/ManagedCompiler.cs
index b137cf9c561e6..a72cdd6b1281c 100644
--- a/src/Compilers/Core/MSBuildTask/ManagedCompiler.cs
+++ b/src/Compilers/Core/MSBuildTask/ManagedCompiler.cs
@@ -227,6 +227,13 @@ public ITaskItem OutputAssembly
             get { return (ITaskItem)_store[nameof(OutputAssembly)]; }
         }
 
+        [Output]
+        public ITaskItem OutputRefAssembly
+        {
+            set { _store[nameof(OutputRefAssembly)] = value; }
+            get { return (ITaskItem)_store[nameof(OutputRefAssembly)]; }
+        }
+
         public string Platform
         {
             set { _store[nameof(Platform)] = value; }
@@ -251,6 +258,12 @@ public ITaskItem[] References
             get { return (ITaskItem[])_store[nameof(References)]; }
         }
 
+        public bool RefOnly
+        {
+            set { _store[nameof(RefOnly)] = value; }
+            get { return _store.GetOrDefault(nameof(RefOnly), false); }
+        }
+
         public bool ReportAnalyzer
         {
             set { _store[nameof(ReportAnalyzer)] = value; }
@@ -705,6 +718,8 @@ protected internal virtual void AddResponseFileCommands(CommandLineBuilderExtens
             commandLine.AppendPlusOrMinusSwitch("/optimize", _store, nameof(Optimize));
             commandLine.AppendSwitchIfNotNull("/pathmap:", PathMap);
             commandLine.AppendSwitchIfNotNull("/out:", OutputAssembly);
+            commandLine.AppendSwitchIfNotNull("/refout:", OutputRefAssembly);
+            commandLine.AppendWhenTrue("/refonly", _store, nameof(RefOnly));
             commandLine.AppendSwitchIfNotNull("/ruleset:", CodeAnalysisRuleSet);
             commandLine.AppendSwitchIfNotNull("/errorlog:", ErrorLog);
             commandLine.AppendSwitchIfNotNull("/subsystemversion:", SubsystemVersion);
diff --git a/src/Compilers/Core/MSBuildTaskTests/CscTests.cs b/src/Compilers/Core/MSBuildTaskTests/CscTests.cs
index 3f538e72d9d7e..bd3e3dd55c145 100644
--- a/src/Compilers/Core/MSBuildTaskTests/CscTests.cs
+++ b/src/Compilers/Core/MSBuildTaskTests/CscTests.cs
@@ -286,5 +286,23 @@ public void Embed()
             csc.EmbeddedFiles = MSBuildUtil.CreateTaskItems();
             Assert.Equal(@"/debug:portable /out:test.exe test.cs", csc.GenerateResponseFileContents());
         }
+
+        [Fact]
+        public void RefOut()
+        {
+            var csc = new Csc();
+            csc.Sources = MSBuildUtil.CreateTaskItems("test.cs");
+            csc.OutputRefAssembly = MSBuildUtil.CreateTaskItem("ref\\test.dll");
+            Assert.Equal("/out:test.exe /refout:ref\\test.dll test.cs", csc.GenerateResponseFileContents());
+        }
+
+        [Fact]
+        public void RefOnly()
+        {
+            var csc = new Csc();
+            csc.Sources = MSBuildUtil.CreateTaskItems("test.cs");
+            csc.RefOnly = true;
+            Assert.Equal("/out:test.exe /refonly test.cs", csc.GenerateResponseFileContents());
+        }
     }
 }
diff --git a/src/Compilers/Core/MSBuildTaskTests/VbcTests.cs b/src/Compilers/Core/MSBuildTaskTests/VbcTests.cs
index 554cc2b11043e..dd0b5ca23fca7 100644
--- a/src/Compilers/Core/MSBuildTaskTests/VbcTests.cs
+++ b/src/Compilers/Core/MSBuildTaskTests/VbcTests.cs
@@ -283,5 +283,23 @@ public void Embed()
             vbc.EmbeddedFiles = MSBuildUtil.CreateTaskItems();
             Assert.Equal(@"/optionstrict:custom /debug:portable /out:test.exe test.vb", vbc.GenerateResponseFileContents());
         }
+
+        [Fact]
+        public void RefOut()
+        {
+            var vbc = new Vbc();
+            vbc.Sources = MSBuildUtil.CreateTaskItems("test.vb");
+            vbc.OutputRefAssembly = MSBuildUtil.CreateTaskItem("ref\\test.dll");
+            Assert.Equal("/optionstrict:custom /out:test.exe /refout:ref\\test.dll test.vb", vbc.GenerateResponseFileContents());
+        }
+
+        [Fact]
+        public void RefOnly()
+        {
+            var vbc = new Vbc();
+            vbc.Sources = MSBuildUtil.CreateTaskItems("test.vb");
+            vbc.RefOnly = true;
+            Assert.Equal("/optionstrict:custom /out:test.exe /refonly test.vb", vbc.GenerateResponseFileContents());
+        }
     }
 }
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
index f7d3bbd3e231d..7dd8597b0b3b5 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
@@ -269,6 +269,15 @@ internal static string CannotEmbedInteropTypesFromModule {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot target net module when emitting ref assembly..
+        /// </summary>
+        internal static string CannotTargetNetModuleWhenEmittingRefAssembly {
+            get {
+                return ResourceManager.GetString("CannotTargetNetModuleWhenEmittingRefAssembly", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Can&apos;t create a module reference to an assembly..
         /// </summary>
@@ -847,6 +856,15 @@ internal static string KeyInPathMapEndsWithSeparator {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Metadata PE stream should not be given when emitting metadata only..
+        /// </summary>
+        internal static string MetadataPeStreamUnexpectedWhenEmittingMetadataOnly {
+            get {
+                return ResourceManager.GetString("MetadataPeStreamUnexpectedWhenEmittingMetadataOnly", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to MetadataReference &apos;{0}&apos; not found to remove..
         /// </summary>
@@ -1027,6 +1045,15 @@ internal static string PdbStreamUnexpectedWhenEmbedding {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to PDB stream should not be given when emitting metadata only..
+        /// </summary>
+        internal static string PdbStreamUnexpectedWhenEmittingMetadataOnly {
+            get {
+                return ResourceManager.GetString("PdbStreamUnexpectedWhenEmittingMetadataOnly", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to PE image doesn&apos;t contain managed metadata..
         /// </summary>
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.resx b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
index 3af8d6f2de563..928a36ef445d3 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.resx
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
@@ -330,6 +330,15 @@
   <data name="PdbStreamUnexpectedWhenEmbedding" xml:space="preserve">
     <value>PDB stream should not be given when embedding PDB into the PE stream.</value>
   </data>
+  <data name="PdbStreamUnexpectedWhenEmittingMetadataOnly" xml:space="preserve">
+    <value>PDB stream should not be given when emitting metadata only.</value>
+  </data>
+  <data name="MetadataPeStreamUnexpectedWhenEmittingMetadataOnly" xml:space="preserve">
+    <value>Metadata PE stream should not be given when emitting metadata only.</value>
+  </data>
+  <data name="CannotTargetNetModuleWhenEmittingRefAssembly" xml:space="preserve">
+    <value>Cannot target net module when emitting ref assembly.</value>
+  </data>
   <data name="InvalidHash" xml:space="preserve">
     <value>Invalid hash.</value>
   </data>
diff --git a/src/Compilers/Core/Portable/CommandLine/CommonCommandLineArguments.cs b/src/Compilers/Core/Portable/CommandLine/CommonCommandLineArguments.cs
index 75c37feaf7c6e..ee5f34e2d4b71 100644
--- a/src/Compilers/Core/Portable/CommandLine/CommonCommandLineArguments.cs
+++ b/src/Compilers/Core/Portable/CommandLine/CommonCommandLineArguments.cs
@@ -85,6 +85,11 @@ public abstract class CommandLineArguments
         /// </summary>
         public string OutputFileName { get; internal set; }
 
+        /// <summary>
+        /// Path of the output ref assembly or null if not specified.
+        /// </summary>
+        public string OutputRefFilePath { get; internal set; }
+
         /// <summary>
         /// Path of the PDB file or null if same as output binary path with .pdb extension.
         /// </summary>
diff --git a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
index 062041c9eb965..21449fc7c2419 100644
--- a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
+++ b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
@@ -253,7 +253,7 @@ private static FileStream OpenFileForReadWithSmallBufferOptimization(string file
             // size, FileStream.Read still allocates the internal buffer.
             return new FileStream(
                 filePath,
-                FileMode.Open, 
+                FileMode.Open,
                 FileAccess.Read,
                 FileShare.ReadWrite,
                 bufferSize: 1,
@@ -561,7 +561,7 @@ internal int RunCore(TextWriter consoleOutput, ErrorLogger errorLogger, Cancella
             {
                 return Failed;
             }
-            
+
             bool reportAnalyzer = false;
             CancellationTokenSource analyzerCts = null;
             AnalyzerManager analyzerManager = null;
@@ -751,11 +751,15 @@ internal int RunCore(TextWriter consoleOutput, ErrorLogger errorLogger, Cancella
                             var peStreamProvider = new CompilerEmitStreamProvider(this, finalPeFilePath);
                             var pdbStreamProviderOpt = emitPdbFile ? new CompilerEmitStreamProvider(this, finalPdbFilePath) : null;
 
+                            string finalRefPeFilePath = Arguments.OutputRefFilePath;
+                            var refPeStreamProviderOpt = finalRefPeFilePath != null ? new CompilerEmitStreamProvider(this, finalRefPeFilePath) : null;
+
                             try
                             {
                                 success = compilation.SerializeToPeStream(
                                     moduleBeingBuilt,
                                     peStreamProvider,
+                                    refPeStreamProviderOpt,
                                     pdbStreamProviderOpt,
                                     testSymWriterFactory: null,
                                     diagnostics: diagnosticBag,
@@ -765,6 +769,7 @@ internal int RunCore(TextWriter consoleOutput, ErrorLogger errorLogger, Cancella
                             finally
                             {
                                 peStreamProvider.Close(diagnosticBag);
+                                refPeStreamProviderOpt?.Close(diagnosticBag);
                                 pdbStreamProviderOpt?.Close(diagnosticBag);
                             }
 
@@ -774,6 +779,10 @@ internal int RunCore(TextWriter consoleOutput, ErrorLogger errorLogger, Cancella
                                 {
                                     touchedFilesLogger.AddWritten(finalPdbFilePath);
                                 }
+                                if (refPeStreamProviderOpt != null)
+                                {
+                                    touchedFilesLogger.AddWritten(finalRefPeFilePath);
+                                }
                                 touchedFilesLogger.AddWritten(finalPeFilePath);
                             }
                         }
@@ -818,48 +827,9 @@ internal int RunCore(TextWriter consoleOutput, ErrorLogger errorLogger, Cancella
                 }
 
                 cancellationToken.ThrowIfCancellationRequested();
-
-                if (Arguments.TouchedFilesPath != null)
+                if (!WriteTouchedFiles(consoleOutput, touchedFilesLogger, finalXmlFilePath))
                 {
-                    Debug.Assert(touchedFilesLogger != null);
-
-                    if (finalXmlFilePath != null)
-                    {
-                        touchedFilesLogger.AddWritten(finalXmlFilePath);
-                    }
-
-                    string readFilesPath = Arguments.TouchedFilesPath + ".read";
-                    string writtenFilesPath = Arguments.TouchedFilesPath + ".write";
-
-                    var readStream = OpenFile(readFilesPath, consoleOutput, mode: FileMode.OpenOrCreate);
-                    var writtenStream = OpenFile(writtenFilesPath, consoleOutput, mode: FileMode.OpenOrCreate);
-
-                    if (readStream == null || writtenStream == null)
-                    {
-                        return Failed;
-                    }
-
-                    string filePath = null;
-                    try
-                    {
-                        filePath = readFilesPath;
-                        using (var writer = new StreamWriter(readStream))
-                        {
-                            touchedFilesLogger.WriteReadPaths(writer);
-                        }
-
-                        filePath = writtenFilesPath;
-                        using (var writer = new StreamWriter(writtenStream))
-                        {
-                            touchedFilesLogger.WriteWrittenPaths(writer);
-                        }
-                    }
-                    catch (Exception e)
-                    {
-                        Debug.Assert(filePath != null);
-                        MessageProvider.ReportStreamWriteException(e, filePath, consoleOutput);
-                        return Failed;
-                    }
+                    return Failed;
                 }
             }
             finally
@@ -888,6 +858,54 @@ internal int RunCore(TextWriter consoleOutput, ErrorLogger errorLogger, Cancella
             return Succeeded;
         }
 
+        private bool WriteTouchedFiles(TextWriter consoleOutput, TouchedFileLogger touchedFilesLogger, string finalXmlFilePath)
+        {
+            if (Arguments.TouchedFilesPath != null)
+            {
+                Debug.Assert(touchedFilesLogger != null);
+
+                if (finalXmlFilePath != null)
+                {
+                    touchedFilesLogger.AddWritten(finalXmlFilePath);
+                }
+
+                string readFilesPath = Arguments.TouchedFilesPath + ".read";
+                string writtenFilesPath = Arguments.TouchedFilesPath + ".write";
+
+                var readStream = OpenFile(readFilesPath, consoleOutput, mode: FileMode.OpenOrCreate);
+                var writtenStream = OpenFile(writtenFilesPath, consoleOutput, mode: FileMode.OpenOrCreate);
+
+                if (readStream == null || writtenStream == null)
+                {
+                    return false;
+                }
+
+                string filePath = null;
+                try
+                {
+                    filePath = readFilesPath;
+                    using (var writer = new StreamWriter(readStream))
+                    {
+                        touchedFilesLogger.WriteReadPaths(writer);
+                    }
+
+                    filePath = writtenFilesPath;
+                    using (var writer = new StreamWriter(writtenStream))
+                    {
+                        touchedFilesLogger.WriteWrittenPaths(writer);
+                    }
+                }
+                catch (Exception e)
+                {
+                    Debug.Assert(filePath != null);
+                    MessageProvider.ReportStreamWriteException(e, filePath, consoleOutput);
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         protected virtual ImmutableArray<AdditionalTextFile> ResolveAdditionalFilesFromArguments(List<DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFilesLogger)
         {
             var builder = ImmutableArray.CreateBuilder<AdditionalTextFile>();
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index 4eeb2bfd0298b..a9ffb9d65fe35 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -1964,10 +1964,38 @@ public EmitResult Emit(
                 cancellationToken);
         }
 
+        // 2.0 BACKCOMPAT OVERLOAD -- DO NOT TOUCH
+        public EmitResult Emit(
+            Stream peStream,
+            Stream pdbStream,
+            Stream xmlDocumentationStream,
+            Stream win32Resources,
+            IEnumerable<ResourceDescription> manifestResources,
+            EmitOptions options,
+            IMethodSymbol debugEntryPoint,
+            Stream sourceLinkStream,
+            IEnumerable<EmbeddedText> embeddedTexts,
+            CancellationToken cancellationToken)
+        {
+            return Emit(
+                peStream,
+                pdbStream,
+                xmlDocumentationStream,
+                win32Resources,
+                manifestResources,
+                options,
+                debugEntryPoint,
+                sourceLinkStream,
+                embeddedTexts,
+                metadataPeStream: null,
+                cancellationToken: cancellationToken);
+        }
+
         /// <summary>
         /// Emit the IL for the compiled source code into the specified stream.
         /// </summary>
         /// <param name="peStream">Stream to which the compilation will be written.</param>
+        /// <param name="metadataPeStream">Stream to which the metadata-only output will be written.</param>
         /// <param name="pdbStream">Stream to which the compilation's debug info will be written.  Null to forego PDB generation.</param>
         /// <param name="xmlDocumentationStream">Stream to which the compilation's XML documentation will be written.  Null to forego XML generation.</param>
         /// <param name="win32Resources">Stream from which the compilation's Win32 resources will be read (in RES format).  
@@ -2008,6 +2036,7 @@ public EmitResult Emit(
             IMethodSymbol debugEntryPoint = null,
             Stream sourceLinkStream = null,
             IEnumerable<EmbeddedText> embeddedTexts = null,
+            Stream metadataPeStream = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
             if (peStream == null)
@@ -2031,6 +2060,28 @@ public EmitResult Emit(
                 {
                     throw new ArgumentException(CodeAnalysisResources.StreamMustSupportWrite, nameof(pdbStream));
                 }
+
+                if (options?.EmitMetadataOnly == true)
+                {
+                    throw new ArgumentException(CodeAnalysisResources.PdbStreamUnexpectedWhenEmittingMetadataOnly, nameof(pdbStream));
+                }
+            }
+
+            if (metadataPeStream != null && options?.EmitMetadataOnly == true)
+            {
+                throw new ArgumentException(CodeAnalysisResources.MetadataPeStreamUnexpectedWhenEmittingMetadataOnly, nameof(metadataPeStream));
+            }
+
+            if (this.Options.OutputKind == OutputKind.NetModule)
+            {
+                if (metadataPeStream != null)
+                {
+                    throw new ArgumentException(CodeAnalysisResources.CannotTargetNetModuleWhenEmittingRefAssembly, nameof(metadataPeStream));
+                }
+                else if (options?.EmitMetadataOnly == true)
+                {
+                    throw new ArgumentException(CodeAnalysisResources.CannotTargetNetModuleWhenEmittingRefAssembly, nameof(options.EmitMetadataOnly));
+                }
             }
 
             if (win32Resources != null)
@@ -2055,6 +2106,7 @@ public EmitResult Emit(
                     throw new ArgumentException(CodeAnalysisResources.StreamMustSupportRead, nameof(sourceLinkStream));
                 }
             }
+
             if (embeddedTexts != null && !embeddedTexts.IsEmpty())
             {
                 if (options == null || 
@@ -2067,6 +2119,7 @@ public EmitResult Emit(
 
             return Emit(
                 peStream,
+                metadataPeStream,
                 pdbStream,
                 xmlDocumentationStream,
                 win32Resources,
@@ -2085,6 +2138,7 @@ public EmitResult Emit(
         /// </summary>
         internal EmitResult Emit(
             Stream peStream,
+            Stream metadataPeStream,
             Stream pdbStream,
             Stream xmlDocumentationStream,
             Stream win32Resources,
@@ -2152,6 +2206,7 @@ internal EmitResult Emit(
                     success = SerializeToPeStream(
                         moduleBeingBuilt,
                         new SimpleEmitStreamProvider(peStream),
+                        (metadataPeStream != null) ? new SimpleEmitStreamProvider(metadataPeStream) : null,
                         (pdbStream != null) ? new SimpleEmitStreamProvider(pdbStream) : null,
                         testData?.SymWriterFactory,
                         diagnostics,
@@ -2318,6 +2373,7 @@ internal CommonPEModuleBuilder CheckOptionsAndCreateModuleBuilder(
         internal bool SerializeToPeStream(
             CommonPEModuleBuilder moduleBeingBuilt,
             EmitStreamProvider peStreamProvider,
+            EmitStreamProvider metadataPeStreamProvider,
             EmitStreamProvider pdbStreamProvider,
             Func<object> testSymWriterFactory,
             DiagnosticBag diagnostics,
@@ -2331,6 +2387,7 @@ internal bool SerializeToPeStream(
             DiagnosticBag metadataDiagnostics = null;
             DiagnosticBag pdbBag = null;
             Stream peStream = null;
+            Stream refPeStream = null;
             Stream portablePdbStream = null;
 
             bool deterministic = IsEmitDeterministic;
@@ -2429,12 +2486,33 @@ internal bool SerializeToPeStream(
                     return retStream;
                 };
 
+                Func<Stream> getRefPeStream;
+                if (metadataPeStreamProvider != null)
+                {
+                    getRefPeStream = () =>
+                    {
+                        if (metadataDiagnostics.HasAnyErrors())
+                        {
+                            return null;
+                        }
+
+                        refPeStream = metadataPeStreamProvider.GetOrCreateStream(metadataDiagnostics);
+                        Debug.Assert(refPeStream != null || metadataDiagnostics.HasAnyErrors());
+                        return refPeStream;
+                    };
+                }
+                else
+                {
+                    getRefPeStream = null;
+                }
+
                 try
                 {
                     if (Cci.PeWriter.WritePeToStream(
                         new EmitContext(moduleBeingBuilt, null, metadataDiagnostics),
                         this.MessageProvider,
                         getPeStream,
+                        getRefPeStream,
                         getPortablePdbStream,
                         nativePdbWriter,
                         pePdbPath,
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
index 8cc8d4d317326..7c8b2fdb0ec67 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
@@ -55,7 +55,7 @@ public DeltaMetadataWriter(
                    dynamicAnalysisDataWriterOpt: null,
                    context: context,
                    messageProvider: messageProvider,
-                   allowMissingMethodBodies: false, 
+                   metadataOnly: false, 
                    deterministic: false,
                    cancellationToken: cancellationToken)
         {
diff --git a/src/Compilers/Core/Portable/PEWriter/FullMetadataWriter.cs b/src/Compilers/Core/Portable/PEWriter/FullMetadataWriter.cs
index ddca0955c2b60..47e8694c2b927 100644
--- a/src/Compilers/Core/Portable/PEWriter/FullMetadataWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/FullMetadataWriter.cs
@@ -37,7 +37,7 @@ internal sealed class FullMetadataWriter : MetadataWriter
         public static MetadataWriter Create(
             EmitContext context,
             CommonMessageProvider messageProvider,
-            bool allowMissingMethodBodies,
+            bool metadataOnly,
             bool deterministic,
             bool hasPdbStream,
             CancellationToken cancellationToken)
@@ -63,7 +63,7 @@ public static MetadataWriter Create(
                 new DynamicAnalysisDataWriter(context.Module.DebugDocumentCount, context.Module.HintNumberOfMethodDefinitions) : 
                 null;
 
-            return new FullMetadataWriter(context, builder, debugBuilderOpt, dynamicAnalysisDataWriterOpt, messageProvider, allowMissingMethodBodies, deterministic, cancellationToken);
+            return new FullMetadataWriter(context, builder, debugBuilderOpt, dynamicAnalysisDataWriterOpt, messageProvider, metadataOnly, deterministic, cancellationToken);
         }
 
         private FullMetadataWriter(
@@ -72,10 +72,10 @@ private FullMetadataWriter(
             MetadataBuilder debugBuilderOpt,
             DynamicAnalysisDataWriter dynamicAnalysisDataWriterOpt,
             CommonMessageProvider messageProvider,
-            bool allowMissingMethodBodies,
+            bool metadataOnly,
             bool deterministic,
             CancellationToken cancellationToken)
-            : base(builder, debugBuilderOpt, dynamicAnalysisDataWriterOpt, context, messageProvider, allowMissingMethodBodies, deterministic, cancellationToken)
+            : base(builder, debugBuilderOpt, dynamicAnalysisDataWriterOpt, context, messageProvider, metadataOnly, deterministic, cancellationToken)
         {
             // EDMAURER make some intelligent guesses for the initial sizes of these things.
             int numMethods = this.module.HintNumberOfMethodDefinitions;
diff --git a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
index c65fe050a3595..d54aee2c74a85 100644
--- a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
@@ -65,25 +65,27 @@ internal abstract partial class MetadataWriter
         private readonly int _numTypeDefsEstimate;
         private readonly bool _deterministic;
 
-        // If true, it is allowed to have methods not have bodies (for emitting metadata-only assembly)
-        internal readonly bool allowMissingMethodBodies;
+        internal readonly bool MetadataOnly;
 
         // A map of method body before token translation to RVA. Used for deduplication of small bodies.
         private readonly Dictionary<ImmutableArray<byte>, int> _smallMethodBodies;
 
+        private static readonly ImmutableArray<byte> ThrowNullIL = ImmutableArray.Create((byte)ILOpCode.Ldnull, (byte)ILOpCode.Throw);
+        private const int ThrowNullMaxStack = 1;
+
         protected MetadataWriter(
             MetadataBuilder metadata,
             MetadataBuilder debugMetadataOpt,
             DynamicAnalysisDataWriter dynamicAnalysisDataWriterOpt,
             EmitContext context,
             CommonMessageProvider messageProvider,
-            bool allowMissingMethodBodies,
+            bool metadataOnly,
             bool deterministic,
             CancellationToken cancellationToken)
         {
             this.module = context.Module;
             _deterministic = deterministic;
-            this.allowMissingMethodBodies = allowMissingMethodBodies;
+            this.MetadataOnly = metadataOnly;
 
             // EDMAURER provide some reasonable size estimates for these that will avoid
             // much of the reallocation that would occur when growing these from empty.
@@ -2831,22 +2833,30 @@ private int[] SerializeMethodBodies(BlobBuilder ilBuilder, PdbWriter nativePdbWr
 
                 if (method.HasBody())
                 {
-                    body = method.GetBody(Context);
-                    Debug.Assert(body != null || allowMissingMethodBodies);
-
-                    if (body != null)
+                    if (MetadataOnly)
                     {
-                        localSignatureHandleOpt = this.SerializeLocalVariablesSignature(body);
-
-                        // TODO: consider parallelizing these (local signature tokens can be piped into IL serialization & debug info generation)
-                        bodyOffset = SerializeMethodBody(encoder, body, localSignatureHandleOpt, ref mvidStringHandle, ref mvidStringFixup);
-
-                        nativePdbWriterOpt?.SerializeDebugInfo(body, localSignatureHandleOpt, customDebugInfoWriter);
+                        bodyOffset = SerializeThrowNullMethodBody(encoder);
+                        localSignatureHandleOpt = default(StandaloneSignatureHandle);
+                        body = null;
                     }
                     else
                     {
-                        bodyOffset = 0;
-                        localSignatureHandleOpt = default(StandaloneSignatureHandle);
+                        body = method.GetBody(Context);
+
+                        if (body != null)
+                        {
+                            localSignatureHandleOpt = this.SerializeLocalVariablesSignature(body);
+
+                            // TODO: consider parallelizing these (local signature tokens can be piped into IL serialization & debug info generation)
+                            bodyOffset = SerializeMethodBody(encoder, body, localSignatureHandleOpt, ref mvidStringHandle, ref mvidStringFixup);
+
+                            nativePdbWriterOpt?.SerializeDebugInfo(body, localSignatureHandleOpt, customDebugInfoWriter);
+                        }
+                        else
+                        {
+                            bodyOffset = 0;
+                            localSignatureHandleOpt = default(StandaloneSignatureHandle);
+                        }
                     }
                 }
                 else
@@ -2863,7 +2873,7 @@ private int[] SerializeMethodBodies(BlobBuilder ilBuilder, PdbWriter nativePdbWr
                 }
 
                 _dynamicAnalysisDataWriterOpt?.SerializeMethodDynamicAnalysisData(body);
-                
+
                 bodyOffsets[methodRid - 1] = bodyOffset;
 
                 methodRid++;
@@ -2872,40 +2882,84 @@ private int[] SerializeMethodBodies(BlobBuilder ilBuilder, PdbWriter nativePdbWr
             return bodyOffsets;
         }
 
-        private int SerializeMethodBody(MethodBodyStreamEncoder encoder, IMethodBody methodBody, StandaloneSignatureHandle localSignatureHandleOpt, ref UserStringHandle mvidStringHandle, ref Blob mvidStringFixup)
-        {
-            int ilLength = methodBody.IL.Length;
-            var exceptionRegions = methodBody.ExceptionRegions;
-            bool isSmallBody = ilLength < 64 && methodBody.MaxStack <= 8 && localSignatureHandleOpt.IsNil && exceptionRegions.Length == 0;
-
-            // Check if an identical method body has already been serialized. 
+        private int SerializeThrowNullMethodBody(MethodBodyStreamEncoder encoder)
+        {
+            UserStringHandle mvidStringHandle = default(UserStringHandle);
+            Blob mvidStringFixup = default(Blob);
+
+            int offset = SerializeMethodBody(
+                encoder,
+                ThrowNullIL,
+                ThrowNullMaxStack,
+                ImmutableArray<ExceptionHandlerRegion>.Empty,
+                default(StandaloneSignatureHandle),
+                MethodBodyAttributes.None,
+                ref mvidStringHandle,
+                ref mvidStringFixup);
+
+            Debug.Assert(mvidStringHandle.Equals(default(UserStringHandle)) && mvidStringFixup.Equals(default(Blob)));
+            return offset;
+        }
+
+        private int SerializeMethodBody(
+            MethodBodyStreamEncoder encoder,
+            IMethodBody methodBody,
+            StandaloneSignatureHandle localSignatureHandleOpt,
+            ref UserStringHandle mvidStringHandle,
+            ref Blob mvidStringFixup)
+        {
+            return SerializeMethodBody(
+                encoder,
+                methodBody.IL,
+                methodBody.MaxStack,
+                methodBody.ExceptionRegions,
+                localSignatureHandleOpt,
+                (methodBody.LocalsAreZeroed ? MethodBodyAttributes.InitLocals : MethodBodyAttributes.None),
+                ref mvidStringHandle,
+                ref mvidStringFixup);
+        }
+
+        private int SerializeMethodBody(
+            MethodBodyStreamEncoder encoder,
+            ImmutableArray<byte> il,
+            ushort maxStack,
+            ImmutableArray<ExceptionHandlerRegion> exceptionRegions,
+            StandaloneSignatureHandle localSignatureHandleOpt,
+            MethodBodyAttributes methodBodyAttributes,
+            ref UserStringHandle mvidStringHandle,
+            ref Blob mvidStringFixup)
+        {
+            int ilLength = il.Length;
+            bool isSmallBody = ilLength < 64 && maxStack <= 8 && localSignatureHandleOpt.IsNil && exceptionRegions.Length == 0;
+
+            // Check if an identical method body has already been serialized.
             // If so, use the RVA of the already serialized one.
             // Note that we don't need to rewrite the fake tokens in the body before looking it up.
 
             // Don't do small body method caching during deterministic builds until this issue is fixed
             // https://github.com/dotnet/roslyn/issues/7595
             int bodyOffset;
-            if (!_deterministic && isSmallBody && _smallMethodBodies.TryGetValue(methodBody.IL, out bodyOffset))
+            if (!_deterministic && isSmallBody && _smallMethodBodies.TryGetValue(il, out bodyOffset))
             {
                 return bodyOffset;
             }
 
             var encodedBody = encoder.AddMethodBody(
-                codeSize: methodBody.IL.Length, 
-                maxStack: methodBody.MaxStack, 
-                exceptionRegionCount: exceptionRegions.Length, 
+                codeSize: ilLength,
+                maxStack: maxStack,
+                exceptionRegionCount: exceptionRegions.Length,
                 hasSmallExceptionRegions: MayUseSmallExceptionHeaders(exceptionRegions),
-                localVariablesSignature: localSignatureHandleOpt, 
-                attributes: (methodBody.LocalsAreZeroed ? MethodBodyAttributes.InitLocals : 0));
+                localVariablesSignature: localSignatureHandleOpt,
+                attributes: methodBodyAttributes);
 
             // Don't do small body method caching during deterministic builds until this issue is fixed
             // https://github.com/dotnet/roslyn/issues/7595
             if (isSmallBody && !_deterministic)
             {
-                _smallMethodBodies.Add(methodBody.IL, encodedBody.Offset);
+                _smallMethodBodies.Add(il, encodedBody.Offset);
             }
 
-            WriteInstructions(encodedBody.Instructions, methodBody.IL, ref mvidStringHandle, ref mvidStringFixup);
+            WriteInstructions(encodedBody.Instructions, il, ref mvidStringHandle, ref mvidStringFixup);
             SerializeMethodBodyExceptionHandlerTable(encodedBody.ExceptionRegions, exceptionRegions);
 
             return encodedBody.Offset;
diff --git a/src/Compilers/Core/Portable/PEWriter/PeWriter.cs b/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
index b2d4a571f38ac..ab65cf637ea89 100644
--- a/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
@@ -26,21 +26,70 @@ public PeWritingException(Exception inner)
 
     internal static class PeWriter
     {
-        public static bool WritePeToStream(
+        internal static bool WritePeToStream(
+             EmitContext context,
+             CommonMessageProvider messageProvider,
+             Func<Stream> getPeStream,
+             Func<Stream> getMetadataPeStreamOpt,
+             Func<Stream> getPortablePdbStreamOpt,
+             PdbWriter nativePdbWriterOpt,
+             string pdbPathOpt,
+             bool metadataOnly,
+             bool isDeterministic,
+             CancellationToken cancellationToken)
+        {
+            if (!WritePeToStream(
+                context,
+                messageProvider,
+                getPeStream,
+                getPortablePdbStreamOpt,
+                nativePdbWriterOpt,
+                pdbPathOpt,
+                metadataOnly,
+                isDeterministic,
+                cancellationToken))
+            {
+                return false;
+            }
+
+            // produce the secondary output (ref assembly) if needed
+            if (getMetadataPeStreamOpt != null)
+            {
+                Debug.Assert(!metadataOnly);
+
+                if (!WritePeToStream(
+                    context,
+                    messageProvider,
+                    getMetadataPeStreamOpt,
+                    getPortablePdbStreamOpt: null,
+                    nativePdbWriterOpt: null,
+                    pdbPathOpt: null,
+                    metadataOnly: true,
+                    isDeterministic: isDeterministic,
+                    cancellationToken: cancellationToken))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        internal static bool WritePeToStream(
             EmitContext context,
             CommonMessageProvider messageProvider,
             Func<Stream> getPeStream,
             Func<Stream> getPortablePdbStreamOpt,
             PdbWriter nativePdbWriterOpt,
             string pdbPathOpt,
-            bool allowMissingMethodBodies,
+            bool metadataOnly,
             bool isDeterministic,
             CancellationToken cancellationToken)
         {
             // If PDB writer is given, we have to have PDB path.
             Debug.Assert(nativePdbWriterOpt == null || pdbPathOpt != null);
 
-            var mdWriter = FullMetadataWriter.Create(context, messageProvider, allowMissingMethodBodies, isDeterministic, getPortablePdbStreamOpt != null, cancellationToken);
+            var mdWriter = FullMetadataWriter.Create(context, messageProvider, metadataOnly, isDeterministic, getPortablePdbStreamOpt != null, cancellationToken);
 
             var properties = context.Module.SerializationProperties;
 
diff --git a/src/Compilers/Core/Portable/PEWriter/ReferenceIndexer.cs b/src/Compilers/Core/Portable/PEWriter/ReferenceIndexer.cs
index 8e4b4e3c166ff..b871a1565f161 100644
--- a/src/Compilers/Core/Portable/PEWriter/ReferenceIndexer.cs
+++ b/src/Compilers/Core/Portable/PEWriter/ReferenceIndexer.cs
@@ -99,7 +99,7 @@ protected override void RecordAssemblyReference(IAssemblyReference assemblyRefer
 
         protected override void ProcessMethodBody(IMethodDefinition method)
         {
-            if (method.HasBody())
+            if (method.HasBody() && !metadataWriter.MetadataOnly)
             {
                 var body = method.GetBody(Context);
 
@@ -119,10 +119,6 @@ protected override void ProcessMethodBody(IMethodDefinition method)
                         }
                     }
                 }
-                else if (!metadataWriter.allowMissingMethodBodies)
-                {
-                    throw ExceptionUtilities.Unreachable;
-                }
             }
         }
 
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index 04a4963d5f804..8e0ebfab4b46c 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -9,12 +9,14 @@
 *REMOVED*static Microsoft.CodeAnalysis.Text.SourceText.From(byte[] buffer, int length, System.Text.Encoding encoding = null, Microsoft.CodeAnalysis.Text.SourceHashAlgorithm checksumAlgorithm = Microsoft.CodeAnalysis.Text.SourceHashAlgorithm.Sha1, bool throwIfBinaryDetected = false) -> Microsoft.CodeAnalysis.Text.SourceText
 Microsoft.CodeAnalysis.CommandLineArguments.DisplayVersion.get -> bool
 Microsoft.CodeAnalysis.CommandLineArguments.EmbeddedFiles.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.CommandLineSourceFile>
+Microsoft.CodeAnalysis.CommandLineArguments.OutputRefFilePath.get -> string
 Microsoft.CodeAnalysis.CommandLineArguments.SourceLink.get -> string
 Microsoft.CodeAnalysis.Compilation.CreateAnonymousTypeSymbol(System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ITypeSymbol> memberTypes, System.Collections.Immutable.ImmutableArray<string> memberNames, System.Collections.Immutable.ImmutableArray<bool> memberIsReadOnly = default(System.Collections.Immutable.ImmutableArray<bool>), System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Location> memberLocations = default(System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Location>)) -> Microsoft.CodeAnalysis.INamedTypeSymbol
 Microsoft.CodeAnalysis.Compilation.CreateErrorNamespaceSymbol(Microsoft.CodeAnalysis.INamespaceSymbol container, string name) -> Microsoft.CodeAnalysis.INamespaceSymbol
 Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol underlyingType, System.Collections.Immutable.ImmutableArray<string> elementNames = default(System.Collections.Immutable.ImmutableArray<string>), System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Location> elementLocations = default(System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Location>)) -> Microsoft.CodeAnalysis.INamedTypeSymbol
 Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ITypeSymbol> elementTypes, System.Collections.Immutable.ImmutableArray<string> elementNames = default(System.Collections.Immutable.ImmutableArray<string>), System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Location> elementLocations = default(System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Location>)) -> Microsoft.CodeAnalysis.INamedTypeSymbol
-Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream peStream, System.IO.Stream pdbStream = null, System.IO.Stream xmlDocumentationStream = null, System.IO.Stream win32Resources = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ResourceDescription> manifestResources = null, Microsoft.CodeAnalysis.Emit.EmitOptions options = null, Microsoft.CodeAnalysis.IMethodSymbol debugEntryPoint = null, System.IO.Stream sourceLinkStream = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.EmbeddedText> embeddedTexts = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Emit.EmitResult
+Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream peStream, System.IO.Stream pdbStream = null, System.IO.Stream xmlDocumentationStream = null, System.IO.Stream win32Resources = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ResourceDescription> manifestResources = null, Microsoft.CodeAnalysis.Emit.EmitOptions options = null, Microsoft.CodeAnalysis.IMethodSymbol debugEntryPoint = null, System.IO.Stream sourceLinkStream = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.EmbeddedText> embeddedTexts = null, System.IO.Stream metadataPeStream = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Emit.EmitResult
+Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream peStream, System.IO.Stream pdbStream, System.IO.Stream xmlDocumentationStream, System.IO.Stream win32Resources, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ResourceDescription> manifestResources, Microsoft.CodeAnalysis.Emit.EmitOptions options, Microsoft.CodeAnalysis.IMethodSymbol debugEntryPoint, System.IO.Stream sourceLinkStream, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.EmbeddedText> embeddedTexts, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.Emit.EmitResult
 Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream peStream, System.IO.Stream pdbStream, System.IO.Stream xmlDocumentationStream, System.IO.Stream win32Resources, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ResourceDescription> manifestResources, Microsoft.CodeAnalysis.Emit.EmitOptions options, Microsoft.CodeAnalysis.IMethodSymbol debugEntryPoint, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.Emit.EmitResult
 Microsoft.CodeAnalysis.Compilation.GetUnreferencedAssemblyIdentities(Microsoft.CodeAnalysis.Diagnostic diagnostic) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.AssemblyIdentity>
 Microsoft.CodeAnalysis.CompilationOptions.WithConcurrentBuild(bool concurrent) -> Microsoft.CodeAnalysis.CompilationOptions
diff --git a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
index 0ff31b101c10c..0b8d40df5a51d 100644
--- a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
+++ b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
@@ -96,6 +96,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Dim noStdLib As Boolean = False
             Dim utf8output As Boolean = False
             Dim outputFileName As String = Nothing
+            Dim outputRefFileName As String = Nothing
+            Dim metadataOnly As Boolean = False
             Dim outputDirectory As String = baseDirectory
             Dim documentationPath As String = Nothing
             Dim errorLogPath As String = Nothing
@@ -455,6 +457,24 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                             End If
                             Continue For
 
+                        Case "refout"
+                            Dim unquoted = RemoveQuotesAndSlashes(value)
+                            If String.IsNullOrEmpty(unquoted) Then
+                                AddDiagnostic(diagnostics, ERRID.ERR_ArgumentRequired, name, ":<file>")
+                            Else
+                                outputRefFileName = ParseGenericPathToFile(unquoted, diagnostics, baseDirectory)
+                            End If
+                            Continue For
+
+                        Case "refonly", "refonly+"
+                            If value IsNot Nothing Then
+                                AddDiagnostic(diagnostics, ERRID.ERR_SwitchNeedsBool, "refonly")
+                            End If
+
+                            metadataOnly = True
+                            Continue For
+
+
                         Case "t", "target"
                             value = RemoveQuotesAndSlashes(value)
                             outputKind = ParseTarget(name, value, diagnostics)
@@ -1194,6 +1214,14 @@ lVbRuntimePlus:
                 specificDiagnosticOptions(item.Key) = item.Value
             Next
 
+            If metadataOnly AndAlso outputRefFileName IsNot Nothing Then
+                AddDiagnostic(diagnostics, ERRID.ERR_NoRefOutWhenRefOnly)
+            End If
+
+            If outputKind = OutputKind.NetModule AndAlso (metadataOnly OrElse outputRefFileName IsNot Nothing) Then
+                AddDiagnostic(diagnostics, ERRID.ERR_NoNetModuleOutputWhenRefOutOrRefOnly)
+            End If
+
             If Not IsScriptRunner AndAlso Not hasSourceFiles AndAlso managedResources.IsEmpty() Then
                 ' VB displays help when there is nothing specified on the command line
                 If flattenedArgs.Any Then
@@ -1344,7 +1372,7 @@ lVbRuntimePlus:
                 reportSuppressedDiagnostics:=reportSuppressedDiagnostics)
 
             Dim emitOptions = New EmitOptions(
-                metadataOnly:=False,
+                metadataOnly:=metadataOnly,
                 debugInformationFormat:=debugInformationFormat,
                 pdbFilePath:=Nothing, ' to be determined later
                 outputNameOverride:=Nothing,  ' to be determined later
@@ -1376,6 +1404,7 @@ lVbRuntimePlus:
                 .Utf8Output = utf8output,
                 .CompilationName = compilationName,
                 .OutputFileName = outputFileName,
+                .OutputRefFilePath = outputRefFileName,
                 .OutputDirectory = outputDirectory,
                 .DocumentationPath = documentationPath,
                 .ErrorLogPath = errorLogPath,
@@ -1403,7 +1432,7 @@ lVbRuntimePlus:
                 .ScriptArguments = scriptArgs.AsImmutableOrEmpty(),
                 .TouchedFilesPath = touchedFilesPath,
                 .OutputLevel = outputLevel,
-                .EmitPdb = emitPdb,
+                .EmitPdb = emitPdb AndAlso Not metadataOnly,
                 .SourceLink = sourceLink,
                 .DefaultCoreLibraryReference = defaultCoreLibraryReference,
                 .PreferredUILang = preferredUILang,
diff --git a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
index 499cd9b6671f3..5f6cf70ab5568 100644
--- a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
+++ b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
@@ -2270,8 +2270,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             diagnostics As DiagnosticBag,
             cancellationToken As CancellationToken) As Boolean
 
-            Debug.Assert(Not moduleBuilder.EmitOptions.EmitMetadataOnly)
-
             ' Use a temporary bag so we don't have to refilter pre-existing diagnostics.
             Dim resourceDiagnostics = DiagnosticBag.GetInstance()
 
diff --git a/src/Compilers/VisualBasic/Portable/Errors/Errors.vb b/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
index 1d21dcb6380ec..b3e8649f35eb1 100644
--- a/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
+++ b/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
@@ -1725,6 +1725,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ERR_BadAssemblyName = 37283
 
         ERR_Merge_conflict_marker_encountered = 37284
+        ERR_NoRefOutWhenRefOnly = 37285
+        ERR_NoNetModuleOutputWhenRefOutOrRefOnly = 37286
 
         '// WARNINGS BEGIN HERE
         WRN_UseOfObsoleteSymbol2 = 40000
diff --git a/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb b/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb
index d0a6f6a7876b2..1bc0c8a864e7d 100644
--- a/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb
+++ b/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb
@@ -8070,6 +8070,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
         
+        '''<summary>
+        '''  Looks up a localized string similar to Cannot compile net modules when using /refout or /refonly..
+        '''</summary>
+        Friend ReadOnly Property ERR_NoNetModuleOutputWhenRefOutOrRefOnly() As String
+            Get
+                Return ResourceManager.GetString("ERR_NoNetModuleOutputWhenRefOutOrRefOnly", resourceCulture)
+            End Get
+        End Property
+        
         '''<summary>
         '''  Looks up a localized string similar to Member &apos;{0}&apos; cannot be initialized in an object initializer expression because it is not a field or property..
         '''</summary>
@@ -8142,6 +8151,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
         
+        '''<summary>
+        '''  Looks up a localized string similar to Do not use refout when using refonly..
+        '''</summary>
+        Friend ReadOnly Property ERR_NoRefOutWhenRefOnly() As String
+            Get
+                Return ResourceManager.GetString("ERR_NoRefOutWhenRefOnly", resourceCulture)
+            End Get
+        End Property
+        
         '''<summary>
         '''  Looks up a localized string similar to unable to open response file &apos;{0}&apos;.
         '''</summary>
diff --git a/src/Compilers/VisualBasic/Portable/VBResources.resx b/src/Compilers/VisualBasic/Portable/VBResources.resx
index 766722e4338af..edebd886374e4 100644
--- a/src/Compilers/VisualBasic/Portable/VBResources.resx
+++ b/src/Compilers/VisualBasic/Portable/VBResources.resx
@@ -5467,4 +5467,10 @@
   <data name="ERR_Merge_conflict_marker_encountered" xml:space="preserve">
     <value>Merge conflict marker encountered</value>
   </data>
+  <data name="ERR_NoRefOutWhenRefOnly" xml:space="preserve">
+    <value>Do not use refout when using refonly.</value>
+  </data>
+  <data name="ERR_NoNetModuleOutputWhenRefOutOrRefOnly" xml:space="preserve">
+    <value>Cannot compile net modules when using /refout or /refonly.</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
index 63e30a52155f2..72541ce5230b7 100644
--- a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
+++ b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
@@ -2787,6 +2787,26 @@ print Goodbye, World"
             Assert.Equal("MyBinary.dll", parsedArgs.CompilationOptions.ModuleName)
             Assert.Equal("C:\My Folder", parsedArgs.OutputDirectory)
 
+            parsedArgs = DefaultParse({"/refout:", "a.vb"}, baseDirectory)
+            parsedArgs.Errors.Verify(
+                Diagnostic(ERRID.ERR_ArgumentRequired).WithArguments("refout", ":<file>").WithLocation(1, 1))
+
+            parsedArgs = DefaultParse({"/refout:ref.dll", "/refonly", "a.vb"}, baseDirectory)
+            parsedArgs.Errors.Verify(
+                Diagnostic(ERRID.ERR_NoRefOutWhenRefOnly).WithLocation(1, 1))
+
+            parsedArgs = DefaultParse({"/refonly:incorrect", "a.vb"}, baseDirectory)
+            parsedArgs.Errors.Verify(
+                Diagnostic(ERRID.ERR_SwitchNeedsBool).WithArguments("refonly").WithLocation(1, 1))
+
+            parsedArgs = DefaultParse({"/refout:ref.dll", "/target:module", "a.vb"}, baseDirectory)
+            parsedArgs.Errors.Verify(
+                Diagnostic(ERRID.ERR_NoNetModuleOutputWhenRefOutOrRefOnly).WithLocation(1, 1))
+
+            parsedArgs = DefaultParse({"/refonly", "/target:module", "a.vb"}, baseDirectory)
+            parsedArgs.Errors.Verify(
+                Diagnostic(ERRID.ERR_NoNetModuleOutputWhenRefOutOrRefOnly).WithLocation(1, 1))
+
             parsedArgs = DefaultParse({"/out:C:\""My Folder""\MyBinary.dll", "/t:library", "a.vb"}, baseDirectory)
             parsedArgs.Errors.Verify(
                     Diagnostic(ERRID.FTL_InputFileNameTooLong).WithArguments("C:""My Folder\MyBinary.dll").WithLocation(1, 1))
@@ -2923,6 +2943,12 @@ print Goodbye, World"
             parsedArgs = DefaultParse({"/OUT:", "a.vb"}, baseDirectory)
             parsedArgs.Errors.Verify(Diagnostic(ERRID.ERR_ArgumentRequired).WithArguments("out", ":<file>"))
 
+            parsedArgs = DefaultParse({"/REFOUT:", "a.vb"}, baseDirectory)
+            parsedArgs.Errors.Verify(Diagnostic(ERRID.ERR_ArgumentRequired).WithArguments("refout", ":<file>"))
+
+            parsedArgs = DefaultParse({"/refout:ref.dll", "/refonly", "a.vb"}, baseDirectory)
+            parsedArgs.Errors.Verify(Diagnostic(ERRID.ERR_NoRefOutWhenRefOnly).WithLocation(1, 1))
+
             parsedArgs = DefaultParse({"/out+", "a.vb"}, baseDirectory)
             parsedArgs.Errors.Verify(Diagnostic(ERRID.WRN_BadSwitch).WithArguments("/out+")) ' TODO: Dev11 reports ERR_ArgumentRequired
 
@@ -7990,6 +8016,175 @@ End Class
             Next
         End Sub
 
+        <Fact>
+        Public Sub RefOut()
+            Dim dir = Temp.CreateDirectory()
+            dir.CreateDirectory("ref")
+
+            Dim src = dir.CreateFile("a.vb")
+            src.WriteAllText("
+Class C
+    ''' <summary>Main method</summary>
+    Public Shared Sub Main()
+        System.Console.Write(""Hello"")
+    End Sub
+End Class")
+
+            Dim outWriter = New StringWriter(CultureInfo.InvariantCulture)
+            Dim vbc = New MockVisualBasicCompiler(Nothing, dir.Path,
+                {"/define:_MYTYPE=""Empty"" ", "/nologo", "/out:a.exe", "/refout:ref/a.dll", "/doc:doc.xml", "/deterministic", "a.vb"})
+
+            Dim exitCode = vbc.Run(outWriter)
+            Assert.Equal(0, exitCode)
+
+            Dim exe = Path.Combine(dir.Path, "a.exe")
+            Assert.True(File.Exists(exe))
+
+            MetadataReaderUtils.VerifyPEMetadata(exe,
+                {"TypeDef:<Module>", "TypeDef:C"},
+                {"MethodDef: Void Main()", "MethodDef: Void .ctor()"},
+                {"CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "STAThreadAttribute"}
+                )
+
+            Dim doc = Path.Combine(dir.Path, "doc.xml")
+            Assert.True(File.Exists(doc))
+
+            Dim content = File.ReadAllText(doc)
+            Dim expectedDoc =
+"<?xml version=""1.0""?>
+<doc>
+<assembly>
+<name>
+a
+</name>
+</assembly>
+<members>
+<member name=""M:C.Main"">
+ <summary>Main method</summary>
+</member>
+</members>
+</doc>"
+            Assert.Equal(expectedDoc, content.Trim())
+
+            Dim output = ProcessUtilities.RunAndGetOutput(exe, startFolder:=dir.Path)
+            Assert.Equal("Hello", output.Trim())
+
+            Dim refDll = Path.Combine(dir.Path, Path.Combine("ref", "a.dll"))
+            Assert.True(File.Exists(refDll))
+
+            ' The types and members that are included needs further refinement.
+            ' ReferenceAssemblyAttribute is missing.
+            ' See issue https://github.com/dotnet/roslyn/issues/17612
+            MetadataReaderUtils.VerifyPEMetadata(refDll,
+                {"TypeDef:<Module>", "TypeDef:C"},
+                {"MethodDef: Void Main()", "MethodDef: Void .ctor()"},
+                {"CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "STAThreadAttribute"}
+                )
+
+            output = ProcessUtilities.RunAndGetOutput(refDll, startFolder:=dir.ToString(), expectedRetCode:=-532462766)
+
+            ' Clean up temp files
+            CleanupAllGeneratedFiles(dir.Path)
+        End Sub
+
+        <Fact>
+        Public Sub RefOutWithError()
+            Dim dir = Temp.CreateDirectory()
+            dir.CreateDirectory("ref")
+
+            Dim src = dir.CreateFile("a.vb")
+            src.WriteAllText(
+"Class C
+    Public Shared Sub Main()
+        Bad()
+    End Sub
+End Class")
+
+            Dim outWriter = New StringWriter(CultureInfo.InvariantCulture)
+            Dim csc = New MockVisualBasicCompiler(Nothing, dir.Path,
+                {"/define:_MYTYPE=""Empty"" ", "/nologo", "/out:a.dll", "/refout:ref/a.dll", "/deterministic", "a.vb"})
+
+            Dim exitCode = csc.Run(outWriter)
+            Assert.Equal(1, exitCode)
+
+            Dim vb = Path.Combine(dir.Path, "a.vb")
+
+            Dim dll = Path.Combine(dir.Path, "a.dll")
+            Assert.False(File.Exists(dll))
+
+            Dim refDll = Path.Combine(dir.Path, Path.Combine("ref", "a.dll"))
+            Assert.False(File.Exists(refDll))
+
+            Assert.Equal(
+$"{vb}(3) : error BC30451: 'Bad' is not declared. It may be inaccessible due to its protection level.
+
+        Bad()
+        ~~~",
+outWriter.ToString().Trim())
+
+            ' Clean up temp files
+            CleanupAllGeneratedFiles(dir.Path)
+        End Sub
+
+        <Fact>
+        Public Sub RefOnly()
+            Dim dir = Temp.CreateDirectory()
+
+            Dim src = dir.CreateFile("a.vb")
+            src.WriteAllText(
+"Class C
+    ''' <summary>Main method</summary>
+    Public Shared Sub Main()
+        Bad()
+    End Sub
+End Class")
+
+            Dim outWriter = New StringWriter(CultureInfo.InvariantCulture)
+            Dim csc = New MockVisualBasicCompiler(Nothing, dir.Path,
+                {"/define:_MYTYPE=""Empty"" ", "/nologo", "/out:a.dll", "/refonly", "/debug", "/deterministic", "/doc:doc.xml", "a.vb"})
+
+            Dim exitCode = csc.Run(outWriter)
+            Assert.Equal(0, exitCode)
+
+            Dim refDll = Path.Combine(dir.Path, "a.dll")
+            Assert.True(File.Exists(refDll))
+
+            ' The types and members that are included needs further refinement.
+            ' ReferenceAssemblyAttribute is missing.
+            ' See issue https://github.com/dotnet/roslyn/issues/17612
+            MetadataReaderUtils.VerifyPEMetadata(refDll,
+                {"TypeDef:<Module>", "TypeDef:C"},
+                {"MethodDef: Void Main()", "MethodDef: Void .ctor()"},
+                {"CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "STAThreadAttribute"}
+                )
+
+            Dim pdb = Path.Combine(dir.Path, "a.pdb")
+            Assert.False(File.Exists(pdb))
+
+            Dim doc = Path.Combine(dir.Path, "doc.xml")
+            Assert.True(File.Exists(doc))
+
+            Dim content = File.ReadAllText(doc)
+            Dim expectedDoc =
+"<?xml version=""1.0""?>
+<doc>
+<assembly>
+<name>
+a
+</name>
+</assembly>
+<members>
+<member name=""M:C.Main"">
+ <summary>Main method</summary>
+</member>
+</members>
+</doc>"
+            Assert.Equal(expectedDoc, content.Trim())
+
+            ' Clean up temp files
+            CleanupAllGeneratedFiles(dir.Path)
+        End Sub
+
         <WorkItem(13681, "https://github.com/dotnet/roslyn/issues/13681")>
         <Theory()>
         <InlineData("/t:exe", "/out:foo.dll", "foo.dll", "foo.dll.exe")>                                'Output with known but different extension
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
index ff3349e10f719..775744fdbbce5 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
@@ -260,7 +260,7 @@ End Namespace
     </file>
 </compilation>)
 
-            Dim emitResult As emitResult
+            Dim emitResult As EmitResult
             Dim mdOnlyImage As Byte()
 
             Using output = New MemoryStream()
@@ -297,6 +297,208 @@ End Class
             End Using
         End Sub
 
+        <Fact>
+        Public Sub RefAssembly_InvariantToSomeChanges()
+
+            RefAssembly_InvariantToSomeChanges(
+"Public Function M() As Integer
+    Return 1
+End Function",
+"Public Function M() As Integer
+    Return 2
+End Function", True)
+
+            RefAssembly_InvariantToSomeChanges(
+"Public Function M() As Integer
+    Return 1
+End Function",
+"Public Function M() As Integer
+End Function", True)
+
+            RefAssembly_InvariantToSomeChanges(
+"",
+"Private Sub M()
+End Sub", False) ' Should be true. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
+
+            RefAssembly_InvariantToSomeChanges(
+"Friend Sub M()
+End Sub",
+"", False)
+
+            RefAssembly_InvariantToSomeChanges(
+"Public Structure S
+    Private Dim i As Integer
+End Structure",
+"Public Structure S
+End Structure", False)
+
+        End Sub
+
+        Private Sub RefAssembly_InvariantToSomeChanges(change1 As String, change2 As String, expectMatch As Boolean)
+            Dim sourceTemplate As String = "
+Public Class C
+    CHANGE
+End Class"
+
+            Dim name As String = GetUniqueName()
+            Dim source1 As String = sourceTemplate.Replace("CHANGE", change1)
+            Dim comp1 = CreateCompilationWithMscorlib(source1,
+                options:=TestOptions.DebugDll.WithDeterministic(True), assemblyName:=name)
+            Dim image1 As ImmutableArray(Of Byte) = comp1.EmitToArray(EmitOptions.Default.WithEmitMetadataOnly(True))
+
+            Dim source2 = sourceTemplate.Replace("CHANGE", change2)
+            Dim comp2 = CreateCompilationWithMscorlib(source2,
+                            options:=TestOptions.DebugDll.WithDeterministic(True), assemblyName:=name)
+            Dim image2 As ImmutableArray(Of Byte) = comp2.EmitToArray(EmitOptions.Default.WithEmitMetadataOnly(True))
+
+            If expectMatch Then
+                AssertEx.Equal(image1, image2)
+            Else
+                AssertEx.NotEqual(image1, image2)
+            End If
+        End Sub
+
+        <Fact>
+        Public Sub RefAssembly_IgnoresSomeDiagnostics()
+
+            RefAssembly_IgnoresSomeDiagnostics(
+"Public Function M() As Integer
+End Function", True)
+
+            RefAssembly_IgnoresSomeDiagnostics(
+"Public Function M() As Integer
+    Error(
+End Function", False) ' Should be true. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
+
+            RefAssembly_IgnoresSomeDiagnostics(
+"Public Function M() As Error
+End Function", False) ' This may get relaxed. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
+        End Sub
+
+        Private Sub RefAssembly_IgnoresSomeDiagnostics(change As String, expectSuccess As Boolean)
+            Dim sourceTemplate As String = "
+Public Class C
+    CHANGE
+End Class"
+
+            Dim name As String = GetUniqueName()
+            Dim source As String = sourceTemplate.Replace("CHANGE", change)
+            Dim comp = CreateCompilationWithMscorlib(source,
+                options:=TestOptions.DebugDll.WithDeterministic(True), assemblyName:=name)
+
+            Using output As New MemoryStream()
+                Dim EmitResult = comp.Emit(output, options:=EmitOptions.Default.WithEmitMetadataOnly(True))
+                Assert.Equal(expectSuccess, EmitResult.Success)
+                Assert.Equal(Not expectSuccess, EmitResult.Diagnostics.Any())
+            End Using
+
+        End Sub
+
+        <Fact>
+        Public Sub VerifyRefAssembly()
+            Dim source = "
+Public MustInherit Class PublicClass
+    Public Sub PublicMethod()
+        System.Console.Write(""Hello"")
+    End Sub
+    Private Sub PrivateMethod()
+        System.Console.Write(""Hello"")
+    End Sub
+    Protected Sub ProtectedMethod()
+        System.Console.Write(""Hello"")
+    End Sub
+    Friend Sub InternalMethod()
+        System.Console.Write(""Hello"")
+    End Sub
+    Public MustOverride Sub AbstractMethod()
+End Class"
+            Dim comp As Compilation = CreateCompilation(source, references:={MscorlibRef},
+                            options:=TestOptions.DebugDll.WithDeterministic(True))
+
+            Dim emitRefOnly = EmitOptions.Default.WithEmitMetadataOnly(True)
+
+            Dim verifier = CompileAndVerify(comp, emitOptions:=emitRefOnly, verify:=True)
+
+            ' verify metadata (types, members, attributes)
+            Dim image = comp.EmitToImageReference(emitRefOnly)
+            Dim comp2 = CreateCompilation("", references:={MscorlibRef, image},
+                            options:=TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All))
+            Dim assembly As AssemblySymbol = comp2.SourceModule.GetReferencedAssemblySymbols().Last()
+            Dim members = assembly.GlobalNamespace.GetMembers()
+            AssertEx.SetEqual(members.Select(Function(m) m.ToDisplayString()),
+                {"<Module>", "PublicClass"})
+
+            AssertEx.SetEqual(
+                DirectCast(assembly.GlobalNamespace.GetMember("PublicClass"), NamedTypeSymbol).GetMembers().
+                                Select(Function(m) m.ToTestDisplayString()),
+                            {"Sub PublicClass.PublicMethod()", "Sub PublicClass.PrivateMethod()",
+                                "Sub PublicClass.InternalMethod()", "Sub PublicClass.ProtectedMethod()",
+                                "Sub PublicClass.AbstractMethod()", "Sub PublicClass..ctor()"})
+
+            AssertEx.SetEqual(assembly.GetAttributes().Select(Function(a) a.AttributeClass.ToTestDisplayString()),
+                {"System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
+                    "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
+                    "System.Diagnostics.DebuggableAttribute"})
+
+            Dim peImage = comp.EmitToArray(emitRefOnly)
+            MetadataReaderUtils.VerifyMethodBodies(peImage, expectEmptyOrThrowNull:=True)
+        End Sub
+
+        <Fact>
+        Public Sub EmitMetadataOnly_DisallowPdbs()
+            Dim comp = CreateCompilation("", references:={MscorlibRef},
+                            options:=TestOptions.DebugDll.WithDeterministic(True))
+
+            Using output As New MemoryStream()
+                Using pdbOutput = New MemoryStream()
+                    Assert.Throws(Of ArgumentException)(Function() comp.Emit(output, pdbOutput,
+                                        options:=EmitOptions.Default.WithEmitMetadataOnly(True)))
+                End Using
+            End Using
+        End Sub
+
+        <Fact>
+        Public Sub EmitMetadataOnly_DisallowMetadataPeStream()
+            Dim comp = CreateCompilation("", references:={MscorlibRef},
+                            options:=TestOptions.DebugDll.WithDeterministic(True))
+
+            Using output As New MemoryStream()
+                Using metadataPeOutput As New MemoryStream()
+                    Assert.Throws(Of ArgumentException)(Function() comp.Emit(output, metadataPeStream:=metadataPeOutput,
+                                        options:=EmitOptions.Default.WithEmitMetadataOnly(True)))
+                End Using
+            End Using
+        End Sub
+
+        <Fact>
+        Public Sub EmitMetadata()
+            Dim source =
+"Public MustInherit Class PublicClass
+    Public Sub PublicMethod
+        System.Console.Write(""Hello"")
+    End Sub
+End Class "
+            Dim comp = CreateCompilation(source, references:={MscorlibRef},
+                            options:=TestOptions.DebugDll.WithDeterministic(True))
+
+            Using output As New MemoryStream()
+                Using pdbOutput As New MemoryStream()
+                    Using metadataOutput As New MemoryStream()
+                        Dim result = comp.Emit(output, pdbOutput, metadataPeStream:=metadataOutput)
+                        Assert.True(result.Success)
+                        Assert.NotEqual(0, output.Position)
+                        Assert.NotEqual(0, pdbOutput.Position)
+                        Assert.NotEqual(0, metadataOutput.Position)
+                        MetadataReaderUtils.VerifyMethodBodies(ImmutableArray.CreateRange(output.GetBuffer()), expectEmptyOrThrowNull:=False)
+                        MetadataReaderUtils.VerifyMethodBodies(ImmutableArray.CreateRange(metadataOutput.GetBuffer()), expectEmptyOrThrowNull:=True)
+                    End Using
+                End Using
+            End Using
+
+            Dim peImage = comp.EmitToArray()
+            MetadataReaderUtils.VerifyMethodBodies(peImage, expectEmptyOrThrowNull:=False)
+        End Sub
+
         <WorkItem(4344, "DevDiv_Projects/Roslyn")>
         <Fact>
         Public Sub Bug4344()
@@ -573,21 +775,21 @@ End Module
             </compilation>
 
             Dim compilation = CreateCompilationWithMscorlib(source, options:=Nothing)
-            Dim peHeaders = New peHeaders(compilation.EmitToStream())
+            Dim peHeaders = New PEHeaders(compilation.EmitToStream())
             Assert.Equal(CorFlags.ILOnly, peHeaders.CorHeader.Flags)
 
             compilation = CreateCompilationWithMscorlib(source, options:=New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithPlatform(Platform.X86))
-            peHeaders = New peHeaders(compilation.EmitToStream())
+            peHeaders = New PEHeaders(compilation.EmitToStream())
             Assert.Equal(CorFlags.ILOnly Or CorFlags.Requires32Bit, peHeaders.CorHeader.Flags)
 
             compilation = CreateCompilationWithMscorlib(source, options:=New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithPlatform(Platform.X64))
-            peHeaders = New peHeaders(compilation.EmitToStream())
+            peHeaders = New PEHeaders(compilation.EmitToStream())
             Assert.Equal(CorFlags.ILOnly, peHeaders.CorHeader.Flags)
             Assert.True(peHeaders.Requires64Bits)
             Assert.True(peHeaders.RequiresAmdInstructionSet)
 
             compilation = CreateCompilationWithMscorlib(source, options:=New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithPlatform(Platform.AnyCpu32BitPreferred))
-            peHeaders = New peHeaders(compilation.EmitToStream())
+            peHeaders = New PEHeaders(compilation.EmitToStream())
             Assert.False(peHeaders.Requires64Bits)
             Assert.False(peHeaders.RequiresAmdInstructionSet)
             Assert.Equal(CorFlags.ILOnly Or CorFlags.Requires32Bit Or CorFlags.Prefers32Bit, peHeaders.CorHeader.Flags)
@@ -606,7 +808,7 @@ End Module
             </compilation>
 
             Dim compilation = CreateCompilationWithMscorlib(source, options:=New VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary).WithPlatform(Platform.AnyCpu))
-            Dim peHeaders = New peHeaders(compilation.EmitToStream())
+            Dim peHeaders = New PEHeaders(compilation.EmitToStream())
 
             'interesting COFF bits
             Assert.False(peHeaders.Requires64Bits)
@@ -631,7 +833,7 @@ End Module
 
             ' test an exe as well:
             compilation = CreateCompilationWithMscorlib(source, options:=New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithPlatform(Platform.AnyCpu))
-            peHeaders = New peHeaders(compilation.EmitToStream())
+            peHeaders = New PEHeaders(compilation.EmitToStream())
 
             'interesting COFF bits
             Assert.False(peHeaders.Requires64Bits)
@@ -667,7 +869,7 @@ End Module
             </compilation>
 
             Dim compilation = CreateCompilationWithMscorlib(source, options:=New VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary).WithPlatform(Platform.Arm))
-            Dim peHeaders = New peHeaders(compilation.EmitToStream())
+            Dim peHeaders = New PEHeaders(compilation.EmitToStream())
 
             'interesting COFF bits
             Assert.False(peHeaders.Requires64Bits)
@@ -692,7 +894,7 @@ End Module
 
             ' test an exe as well:
             compilation = CreateCompilationWithMscorlib(source, options:=New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithPlatform(Platform.AnyCpu))
-            peHeaders = New peHeaders(compilation.EmitToStream())
+            peHeaders = New PEHeaders(compilation.EmitToStream())
 
             'interesting COFF bits
             Assert.False(peHeaders.Requires64Bits)
@@ -728,7 +930,7 @@ End Module
             </compilation>
 
             Dim compilation = CreateCompilationWithMscorlib(source, options:=New VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary).WithPlatform(Platform.X64))
-            Dim peHeaders = New peHeaders(compilation.EmitToStream())
+            Dim peHeaders = New PEHeaders(compilation.EmitToStream())
 
             'interesting COFF bits
             Assert.True(peHeaders.Requires64Bits)
@@ -748,7 +950,7 @@ End Module
 
             ' test an exe as well:
             compilation = CreateCompilationWithMscorlib(source, options:=New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithPlatform(Platform.X64))
-            peHeaders = New peHeaders(compilation.EmitToStream())
+            peHeaders = New PEHeaders(compilation.EmitToStream())
 
             'interesting COFF bits
             Assert.True(peHeaders.Requires64Bits)
@@ -804,7 +1006,7 @@ End Module
             </compilation>
 
             Dim compilation = CreateCompilationWithMscorlib(source, options:=New VisualBasicCompilationOptions(OutputKind.WindowsRuntimeApplication))
-            Dim peHeaders = New peHeaders(compilation.EmitToStream())
+            Dim peHeaders = New PEHeaders(compilation.EmitToStream())
             Assert.Equal(CType(&H9540, UShort), peHeaders.PEHeader.DllCharacteristics)  'DYNAMIC_BASE | NX_COMPAT | NO_SEH | TERMINAL_SERVER_AWARE | HIGH_ENTROPY_VA (0x20)
         End Sub
 
@@ -837,15 +1039,15 @@ End Module
 
             ' default for 32 bit
             compilation = CreateCompilationWithMscorlib(source, options:=TestOptions.ReleaseExe.WithPlatform(Platform.X86))
-            peHeaders = New peHeaders(compilation.EmitToStream())
+            peHeaders = New PEHeaders(compilation.EmitToStream())
             Assert.Equal(&H400000UL, peHeaders.PEHeader.ImageBase)
 
             compilation = CreateCompilationWithMscorlib(source, options:=TestOptions.ReleaseExe.WithPlatform(Platform.X64))
-            peHeaders = New peHeaders(compilation.EmitToStream())
+            peHeaders = New PEHeaders(compilation.EmitToStream())
             Assert.Equal(&H140000000UL, peHeaders.PEHeader.ImageBase)
 
             compilation = CreateCompilationWithMscorlib(source, options:=TestOptions.ReleaseDll.WithPlatform(Platform.X64))
-            peHeaders = New peHeaders(compilation.EmitToStream())
+            peHeaders = New PEHeaders(compilation.EmitToStream())
             Assert.Equal(&H180000000UL, peHeaders.PEHeader.ImageBase)
 
         End Sub
@@ -867,7 +1069,7 @@ End Module
             Assert.Equal(1024, peHeaders.PEHeader.FileAlignment)
 
             compilation = CreateCompilationWithMscorlib(source)
-            peHeaders = New peHeaders(compilation.EmitToStream(options:=New EmitOptions(fileAlignment:=4096)))
+            peHeaders = New PEHeaders(compilation.EmitToStream(options:=New EmitOptions(fileAlignment:=4096)))
             Assert.Equal(4096, peHeaders.PEHeader.FileAlignment)
         End Sub
 
@@ -1743,7 +1945,7 @@ end namespace
                     Dim sourceAssembly = DirectCast(assembly, SourceAssemblySymbol)
                     Dim compilation = sourceAssembly.DeclaringCompilation
 
-                    Dim emitOptions = New emitOptions(outputNameOverride:=sourceAssembly.Name)
+                    Dim emitOptions = New EmitOptions(outputNameOverride:=sourceAssembly.Name)
 
                     Dim assemblyBuilder = New PEAssemblyBuilder(sourceAssembly, emitOptions, OutputKind.DynamicallyLinkedLibrary, GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable(Of ResourceDescription), Nothing)
                     Dim assemblySecurityAttributes As IEnumerable(Of Cci.SecurityAttribute) = assemblyBuilder.GetSourceAssemblySecurityAttributes()
diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs
index cda9d235db5cc..cc1ba417828aa 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs
@@ -263,7 +263,7 @@ internal override CompileResult CompileExpression(
                     getPortablePdbStreamOpt: null,
                     nativePdbWriterOpt: null,
                     pdbPathOpt: null,
-                    allowMissingMethodBodies: false,
+                    metadataOnly: false,
                     isDeterministic: false,
                     cancellationToken: default(CancellationToken));
 
@@ -352,7 +352,7 @@ internal override CompileResult CompileAssignment(
                     getPortablePdbStreamOpt: null,
                     nativePdbWriterOpt: null,
                     pdbPathOpt: null,
-                    allowMissingMethodBodies: false,
+                    metadataOnly: false,
                     isDeterministic: false,
                     cancellationToken: default(CancellationToken));
 
@@ -396,7 +396,7 @@ internal override ReadOnlyCollection<byte> CompileGetLocals(
                         getPortablePdbStreamOpt: null,
                         nativePdbWriterOpt: null,
                         pdbPathOpt: null,
-                        allowMissingMethodBodies: false,
+                        metadataOnly: false,
                         isDeterministic: false,
                         cancellationToken: default(CancellationToken));
 
diff --git a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs
index 2d4096440e450..64257ff58dd09 100644
--- a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs
+++ b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs
@@ -789,7 +789,7 @@ internal static void EmitCorLibWithAssemblyReferences(
                         () => peStream,
                         () => pdbStream,
                         null, null,
-                        allowMissingMethodBodies: true,
+                        metadataOnly: true,
                         isDeterministic: false,
                         cancellationToken: default(CancellationToken));
 
diff --git a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/EvaluationContext.vb b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/EvaluationContext.vb
index 619b89fb23c8b..2dc724c6a37fd 100644
--- a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/EvaluationContext.vb
+++ b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/EvaluationContext.vb
@@ -398,7 +398,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
                         getPortablePdbStreamOpt:=Nothing,
                         nativePdbWriterOpt:=Nothing,
                         pdbPathOpt:=Nothing,
-                        allowMissingMethodBodies:=False,
+                        metadataOnly:=False,
                         isDeterministic:=False,
                         cancellationToken:=Nothing)
 
@@ -442,7 +442,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
                         getPortablePdbStreamOpt:=Nothing,
                         nativePdbWriterOpt:=Nothing,
                         pdbPathOpt:=Nothing,
-                        allowMissingMethodBodies:=False,
+                        metadataOnly:=False,
                         isDeterministic:=False,
                         cancellationToken:=Nothing)
 
@@ -486,7 +486,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
                         getPortablePdbStreamOpt:=Nothing,
                         nativePdbWriterOpt:=Nothing,
                         pdbPathOpt:=Nothing,
-                        allowMissingMethodBodies:=False,
+                        metadataOnly:=False,
                         isDeterministic:=False,
                         cancellationToken:=Nothing)
 
diff --git a/src/Test/Utilities/Portable/Assert/AssertEx.cs b/src/Test/Utilities/Portable/Assert/AssertEx.cs
index 55f36d0a7b1bd..b52bb6578990c 100644
--- a/src/Test/Utilities/Portable/Assert/AssertEx.cs
+++ b/src/Test/Utilities/Portable/Assert/AssertEx.cs
@@ -210,6 +210,24 @@ public static void Equal<T>(IEnumerable<T> expected, IEnumerable<T> actual, IEqu
             }
         }
 
+        public static void NotEqual<T>(IEnumerable<T> expected, IEnumerable<T> actual, IEqualityComparer<T> comparer = null, string message = null,
+            string itemSeparator = null, Func<T, string> itemInspector = null)
+        {
+            if (ReferenceEquals(expected, actual))
+            {
+                Fail("expected and actual references are identical\r\n" + message);
+            }
+
+            if (expected == null || actual == null)
+            {
+                return;
+            }
+            else if (SequenceEqual(expected, actual, comparer))
+            {
+                Fail("expected and actual sequences match\r\n" + message);
+            }
+        }
+
         private static bool SequenceEqual<T>(IEnumerable<T> expected, IEnumerable<T> actual, IEqualityComparer<T> comparer = null)
         {
             var enumerator1 = expected.GetEnumerator();
diff --git a/src/Test/Utilities/Portable/Compilation/CompilationExtensions.cs b/src/Test/Utilities/Portable/Compilation/CompilationExtensions.cs
index acb32e390b463..f3bcd50536fbf 100644
--- a/src/Test/Utilities/Portable/Compilation/CompilationExtensions.cs
+++ b/src/Test/Utilities/Portable/Compilation/CompilationExtensions.cs
@@ -45,6 +45,7 @@ internal static ImmutableArray<byte> EmitToArray(
 
             var emitResult = compilation.Emit(
                 peStream: peStream,
+                metadataPeStream: null,
                 pdbStream: pdbStream,
                 xmlDocumentationStream: null,
                 win32Resources: null,
diff --git a/src/Test/Utilities/Portable/Compilation/IRuntimeEnvironment.cs b/src/Test/Utilities/Portable/Compilation/IRuntimeEnvironment.cs
index bee66b9519f56..b767804c589bb 100644
--- a/src/Test/Utilities/Portable/Compilation/IRuntimeEnvironment.cs
+++ b/src/Test/Utilities/Portable/Compilation/IRuntimeEnvironment.cs
@@ -235,6 +235,7 @@ EmitOptions emitOptions
                 {
                     result = compilation.Emit(
                         executableStream,
+                        metadataPeStream: null,
                         pdbStream: pdbStream,
                         xmlDocumentationStream: null,
                         win32Resources: null,
diff --git a/src/Test/Utilities/Portable/Metadata/MetadataReaderUtils.cs b/src/Test/Utilities/Portable/Metadata/MetadataReaderUtils.cs
index 025cf50f99b6d..5e1f8db49ddf5 100644
--- a/src/Test/Utilities/Portable/Metadata/MetadataReaderUtils.cs
+++ b/src/Test/Utilities/Portable/Metadata/MetadataReaderUtils.cs
@@ -265,9 +265,147 @@ public static string Dump(this MetadataReader reader, EntityHandle handle)
             {
                 case HandleKind.AssemblyReference:
                     return "AssemblyRef:" + reader.GetString(reader.GetAssemblyReference((AssemblyReferenceHandle)handle).Name);
+                case HandleKind.TypeDefinition:
+                    return "TypeDef:" + reader.GetString(reader.GetTypeDefinition((TypeDefinitionHandle)handle).Name);
+                case HandleKind.MethodDefinition:
+                    var method = reader.GetMethodDefinition((MethodDefinitionHandle)handle);
+                    var blob = reader.GetBlobReader(method.Signature);
+                    var decoder = new SignatureDecoder<string, object>(ConstantSignatureVisualizer.Instance, reader, genericContext: null);
+                    var signature =  decoder.DecodeMethodSignature(ref blob);
+                    var parameters = signature.ParameterTypes.Join(", ");
+                    return $"MethodDef: {signature.ReturnType} {reader.GetString(method.Name)}({parameters})";
                 default:
                     return handle.Kind.ToString();
             }
         }
+
+        private sealed class ConstantSignatureVisualizer : ISignatureTypeProvider<string, object>
+        {
+            public static readonly ConstantSignatureVisualizer Instance = new ConstantSignatureVisualizer();
+
+            public string GetArrayType(string elementType, ArrayShape shape)
+            {
+                return elementType + "[" + new string(',', shape.Rank) + "]";
+            }
+
+            public string GetByReferenceType(string elementType)
+            {
+                return elementType + "&";
+            }
+
+            public string GetFunctionPointerType(MethodSignature<string> signature)
+            {
+                return "method-ptr";
+            }
+
+            public string GetGenericInstantiation(string genericType, ImmutableArray<string> typeArguments)
+            {
+                return genericType + "{" + string.Join(", ", typeArguments) + "}";
+            }
+
+            public string GetGenericMethodParameter(object genericContext, int index)
+            {
+                return "!!" + index;
+            }
+
+            public string GetGenericTypeParameter(object genericContext, int index)
+            {
+                return "!" + index;
+            }
+
+            public string GetModifiedType(string modifier, string unmodifiedType, bool isRequired)
+            {
+                return (isRequired ? "modreq" : "modopt") + "(" + modifier + ") " + unmodifiedType;
+            }
+
+            public string GetPinnedType(string elementType)
+            {
+                return "pinned " + elementType;
+            }
+
+            public string GetPointerType(string elementType)
+            {
+                return elementType + "*";
+            }
+
+            public string GetPrimitiveType(PrimitiveTypeCode typeCode)
+            {
+                return typeCode.ToString();
+            }
+
+            public string GetSZArrayType(string elementType)
+            {
+                return elementType + "[]";
+            }
+
+            public string GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind)
+            {
+                var typeDef = reader.GetTypeDefinition(handle);
+                var name = reader.GetString(typeDef.Name);
+                return typeDef.Namespace.IsNil ? name : reader.GetString(typeDef.Namespace) + "." + name;
+            }
+
+            public string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind)
+            {
+                var typeRef = reader.GetTypeReference(handle);
+                var name = reader.GetString(typeRef.Name);
+                return typeRef.Namespace.IsNil ? name : reader.GetString(typeRef.Namespace) + "." + name;
+            }
+
+            public string GetTypeFromSpecification(MetadataReader reader, object genericContext, TypeSpecificationHandle handle, byte rawTypeKind)
+            {
+                var sigReader = reader.GetBlobReader(reader.GetTypeSpecification(handle).Signature);
+                return new SignatureDecoder<string, object>(Instance, reader, genericContext).DecodeType(ref sigReader);
+            }
+        }
+
+        internal static void VerifyPEMetadata(string pePath, string[] types, string[] methods, string[] attributes)
+        {
+            using (var peStream = File.OpenRead(pePath))
+            using (var refPeReader = new PEReader(peStream))
+            {
+                var metadataReader = refPeReader.GetMetadataReader();
+
+                AssertEx.SetEqual(metadataReader.TypeDefinitions.Select(t => metadataReader.Dump(t)), types);
+                AssertEx.SetEqual(metadataReader.MethodDefinitions.Select(t => metadataReader.Dump(t)), methods);
+
+                AssertEx.SetEqual(
+                    metadataReader.CustomAttributes.Select(a => metadataReader.GetCustomAttribute(a).Constructor)
+                        .Select(c => metadataReader.GetMemberReference((MemberReferenceHandle)c).Parent)
+                        .Select(p => metadataReader.GetTypeReference((TypeReferenceHandle)p).Name)
+                        .Select(n => metadataReader.GetString(n)),
+                    attributes);
+            }
+        }
+
+        /// <summary>
+        /// Asserts that all the method bodies in the PE are empty or `throw null`, if expectEmptyOrThrowNull is true.
+        /// Asserts that none of the methods bodies are empty or `throw null`, if expectEmptyOrThrowNull is false.
+        /// </summary>
+        internal static void VerifyMethodBodies(ImmutableArray<byte> peImage, bool expectEmptyOrThrowNull)
+        {
+            using (var peReader = new PEReader(peImage))
+            {
+                var metadataReader = peReader.GetMetadataReader();
+                foreach (var method in metadataReader.MethodDefinitions)
+                {
+                    var rva = metadataReader.GetMethodDefinition(method).RelativeVirtualAddress;
+                    if (rva != 0)
+                    {
+                        var il = peReader.GetMethodBody(rva).GetILBytes();
+                        var throwNull = new[] { (byte)ILOpCode.Ldnull, (byte)ILOpCode.Throw };
+
+                        if (expectEmptyOrThrowNull)
+                        {
+                            AssertEx.Equal(throwNull, il);
+                        }
+                        else
+                        {
+                            AssertEx.NotEqual(throwNull, il);
+                        }
+                    }
+                }
+            }
+        }
     }
 }

From da63887be99377ca8387e87782031f896d21e75e Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Wed, 22 Mar 2017 16:29:31 -0700
Subject: [PATCH 004/284] Allow building nuget package from features/refout
 branch (#18082)

---
 build/Targets/Versions.props            | 3 ++-
 src/Tools/MicroBuild/publish-assets.ps1 | 1 +
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/build/Targets/Versions.props b/build/Targets/Versions.props
index 548467b0d76d0..5467a46929d4f 100644
--- a/build/Targets/Versions.props
+++ b/build/Targets/Versions.props
@@ -14,7 +14,8 @@
     <!-- The release moniker for our packages.  Developers should use "dev" and official builds pick the branch
          moniker listed below -->
     <RoslynNuGetMoniker Condition="'$(RoslynNuGetMoniker)' == ''">dev</RoslynNuGetMoniker>
-    <RoslynNuGetMoniker Condition="'$(OfficialBuild)' == 'true'">beta1</RoslynNuGetMoniker>
+    <!-- PROTOTYPE(refout) This needs to be reverted before merging to master -->
+    <RoslynNuGetMoniker Condition="'$(OfficialBuild)' == 'true'">refout</RoslynNuGetMoniker>
     <!-- This is the base of the NuGet versioning for prerelease packages -->
     <NuGetPreReleaseVersion>$(RoslynFileVersionBase)-$(RoslynNuGetMoniker)</NuGetPreReleaseVersion>
 
diff --git a/src/Tools/MicroBuild/publish-assets.ps1 b/src/Tools/MicroBuild/publish-assets.ps1
index 671696f880cf1..cb04801db8162 100644
--- a/src/Tools/MicroBuild/publish-assets.ps1
+++ b/src/Tools/MicroBuild/publish-assets.ps1
@@ -43,6 +43,7 @@ try
         "dev15.0.x" { } 
         "master" { } 
         "post-dev15" { } 
+        "features/refout" { }
         default
         {
             if (-not $test)

From 2d8158d8f1968b3ea6e1579ede1beee762db3fd4 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Thu, 23 Mar 2017 13:21:37 -0700
Subject: [PATCH 005/284] Make refout tests more resilient to environment
 differences (#18114)

---
 .../Test/CommandLine/CommandLineTests.cs      | 42 +++++++++++++++++--
 .../Test/CommandLine/CommandLineTests.vb      | 37 ++++++++++++++--
 2 files changed, 71 insertions(+), 8 deletions(-)

diff --git a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
index d2534145ba37e..76b0111e77675 100644
--- a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
+++ b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
@@ -8915,11 +8915,11 @@ public void Version()
         public void RefOut()
         {
             var dir = Temp.CreateDirectory();
-            dir.CreateDirectory("ref");
+            var refDir = dir.CreateDirectory("ref");
 
             var src = dir.CreateFile("a.cs");
             src.WriteAllText(@"
-class C
+public class C
 {
     /// <summary>Main method</summary>
     public static void Main()
@@ -8965,7 +8965,7 @@ public static void Main()
             var output = ProcessUtilities.RunAndGetOutput(exe, startFolder: dir.Path);
             Assert.Equal("Hello", output.Trim());
 
-            var refDll = Path.Combine(dir.Path, Path.Combine("ref", "a.dll"));
+            var refDll = Path.Combine(refDir.Path, "a.dll");
             Assert.True(File.Exists(refDll));
 
             // The types and members that are included needs further refinement.
@@ -8977,10 +8977,44 @@ public static void Main()
                 new[] { "CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute" }
                 );
 
-            output = ProcessUtilities.RunAndGetOutput(refDll, startFolder: dir.ToString(), expectedRetCode: -532462766);
+            VerifyNullReferenceException(refDir, "a.dll");
 
             // Clean up temp files
             CleanupAllGeneratedFiles(dir.Path);
+            CleanupAllGeneratedFiles(refDir.Path);
+        }
+
+        /// <summary>
+        /// Calls C.Main() on the program and verifies that a null reference exception is thrown.
+        /// </summary>
+        private static void VerifyNullReferenceException(TempDirectory dir, string programName)
+        {
+            var src = dir.CreateFile("verifier.cs");
+            src.WriteAllText(@"
+class Verifier
+{
+    public static void Main()
+    {
+        try
+        {
+            C.Main();
+        }
+        catch(System.NullReferenceException)
+        {
+            System.Console.Write(""Got expected exception"");
+        }
+    }
+}");
+
+            var outWriter = new StringWriter(CultureInfo.InvariantCulture);
+            var csc = new MockCSharpCompiler(null, dir.Path,
+                new[] { "/nologo", "/out:verifier.exe", $"/reference:{programName}", "verifier.cs" });
+
+            int exitCode = csc.Run(outWriter);
+            Assert.Equal(0, exitCode);
+            string dirPath = dir.ToString();
+            string output = ProcessUtilities.RunAndGetOutput(Path.Combine(dirPath, "verifier.exe"), startFolder: dirPath, expectedRetCode: 0);
+            Assert.Equal("Got expected exception", output);
         }
 
         [Fact]
diff --git a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
index 72541ce5230b7..7844775a85fd5 100644
--- a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
+++ b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
@@ -8019,11 +8019,11 @@ End Class
         <Fact>
         Public Sub RefOut()
             Dim dir = Temp.CreateDirectory()
-            dir.CreateDirectory("ref")
+            Dim refDir = dir.CreateDirectory("ref")
 
             Dim src = dir.CreateFile("a.vb")
             src.WriteAllText("
-Class C
+Public Class C
     ''' <summary>Main method</summary>
     Public Shared Sub Main()
         System.Console.Write(""Hello"")
@@ -8069,7 +8069,7 @@ a
             Dim output = ProcessUtilities.RunAndGetOutput(exe, startFolder:=dir.Path)
             Assert.Equal("Hello", output.Trim())
 
-            Dim refDll = Path.Combine(dir.Path, Path.Combine("ref", "a.dll"))
+            Dim refDll = Path.Combine(refDir.Path, "a.dll")
             Assert.True(File.Exists(refDll))
 
             ' The types and members that are included needs further refinement.
@@ -8081,10 +8081,39 @@ a
                 {"CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "STAThreadAttribute"}
                 )
 
-            output = ProcessUtilities.RunAndGetOutput(refDll, startFolder:=dir.ToString(), expectedRetCode:=-532462766)
+            VerifyNullReferenceException(refDir, "a.dll")
 
             ' Clean up temp files
             CleanupAllGeneratedFiles(dir.Path)
+            CleanupAllGeneratedFiles(refDir.Path)
+        End Sub
+
+        ''' <summary>
+        ''' Calls C.Main() on the program and verifies that a null reference exception is thrown.
+        ''' </summary>
+        Private Shared Sub VerifyNullReferenceException(dir As TempDirectory, referenceName As String)
+
+            Dim src = dir.CreateFile("verifier.vb")
+            src.WriteAllText("
+Class Verifier
+    Public Shared Sub Main()
+        Try
+            C.Main()
+        Catch ex As System.NullReferenceException
+            System.Console.Write(""Got expected exception"")
+        End Try
+    End Sub
+End Class")
+
+            Dim outWriter = New StringWriter(CultureInfo.InvariantCulture)
+            Dim vbc = New MockVisualBasicCompiler(Nothing, dir.Path,
+                {"/define:_MYTYPE=""Empty"" ", "/nologo", "/out:verifier.exe", $"/reference:{referenceName}", "verifier.vb"})
+
+            Dim exitCode = vbc.Run(outWriter)
+            Assert.Equal(0, exitCode)
+            Dim dirPath As String = dir.ToString()
+            Dim output = ProcessUtilities.RunAndGetOutput(Path.Combine(dirPath, "verifier.exe"), startFolder:=dirPath, expectedRetCode:=0)
+            Assert.Equal("Got expected exception", output)
         End Sub
 
         <Fact>

From 5fef4b210ba576fb6ba70c69ddfeda05f7623a72 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Thu, 23 Mar 2017 16:35:02 -0700
Subject: [PATCH 006/284] Fix publish-assets.ps1 for refout feature branch
 (#18129)

---
 src/Tools/MicroBuild/publish-assets.ps1 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Tools/MicroBuild/publish-assets.ps1 b/src/Tools/MicroBuild/publish-assets.ps1
index cb04801db8162..3e9b505aa03cc 100644
--- a/src/Tools/MicroBuild/publish-assets.ps1
+++ b/src/Tools/MicroBuild/publish-assets.ps1
@@ -43,7 +43,7 @@ try
         "dev15.0.x" { } 
         "master" { } 
         "post-dev15" { } 
-        "features/refout" { }
+        "features_refout" { }
         default
         {
             if (-not $test)

From 20aa0c2fae8a0326540328cb6d759d64cd891901 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Fri, 24 Mar 2017 19:29:03 -0700
Subject: [PATCH 007/284] Ref assemblies: Address more feedback on #17558
 (#18091)

---
 .../CSharp/Portable/CSharpResources.resx      |   2 +
 .../CommandLine/CSharpCommandLineParser.cs    |   2 +-
 .../Test/Emit/Emit/CompilationEmitTests.cs    |  54 ++++++-
 .../CSharp/Test/Emit/PDB/PDBTests.cs          |   6 +-
 .../CodeAnalysisResources.Designer.cs         |   9 ++
 .../Core/Portable/CodeAnalysisResources.resx  |   3 +
 .../Core/Portable/Compilation/Compilation.cs  |  83 +++++++++--
 .../Portable/PEWriter/FullMetadataWriter.cs   |   2 +-
 .../Core/Portable/PEWriter/MetadataWriter.cs  | 139 ++++++++----------
 .../Core/Portable/PEWriter/PeWriter.cs        |  49 ------
 .../Core/Portable/PublicAPI.Unshipped.txt     |   2 +-
 .../VisualBasicCommandLineParser.vb           |   2 +-
 .../VisualBasic/Portable/VBResources.resx     |   2 +
 .../Test/Emit/Emit/CompilationEmitTests.vb    |  12 +-
 .../Compilation/CompilationExtensions.cs      |   2 +-
 .../Compilation/IRuntimeEnvironment.cs        |   2 +-
 .../Portable/Metadata/MetadataReaderUtils.cs  |  89 ++++++-----
 17 files changed, 249 insertions(+), 211 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index a0e2a83ab5045..84fd32a1ba6e3 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -4402,6 +4402,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
  /target:winmdobj              Build a Windows Runtime intermediate file that 
                                is consumed by WinMDExp (Short form: /t:winmdobj)
  /doc:&lt;file&gt;                   XML Documentation file to generate
+ /refout:&lt;file&gt;                Reference assembly output to generate
  /platform:&lt;string&gt;            Limit which platforms this code can run on: x86,
                                Itanium, x64, arm, anycpu32bitpreferred, or 
                                anycpu. The default is anycpu.
@@ -4445,6 +4446,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
  /optimize[+|-]                Enable optimizations (Short form: /o)
  /deterministic                Produce a deterministic assembly
                                (including module version GUID and timestamp)
+ /refonly                      Produce a reference assembly in place of the main output
  /instrument:TestCoverage      Produce an assembly instrumented to collect
                                coverage information
  /sourcelink:&lt;file&gt;            Source link info to embed into Portable PDB.
diff --git a/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs b/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
index afbd776426d49..7d19a65d1ac3b 100644
--- a/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
+++ b/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
@@ -1322,7 +1322,7 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
                 OutputFileName = outputFileName,
                 OutputRefFilePath = outputRefFilePath,
                 PdbPath = pdbPath,
-                EmitPdb = emitPdb && !metadataOnly,
+                EmitPdb = emitPdb && !metadataOnly, // silently ignore emitPdb when metadataOnly is set
                 SourceLink = sourceLink,
                 OutputDirectory = outputDirectory,
                 DocumentationPath = documentationPath,
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
index bd115c7776b04..20b13f8ac0e1c 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
@@ -339,7 +339,7 @@ public abstract class PublicClass
                     "System.Diagnostics.DebuggableAttribute" });
 
             var peImage = comp.EmitToArray(emitRefOnly);
-            MetadataReaderUtils.VerifyMethodBodies(peImage, expectEmptyOrThrowNull: true);
+            MetadataReaderUtils.AssertEmptyOrThrowNull(peImage);
         }
         [Fact]
         public void EmitMetadataOnly_DisallowPdbs()
@@ -364,7 +364,7 @@ public void EmitMetadataOnly_DisallowMetadataPeStream()
             using (var output = new MemoryStream())
             using (var metadataPeOutput = new MemoryStream())
             {
-                Assert.Throws<ArgumentException>(() => comp.Emit(output, metadataPeStream: metadataPeOutput,
+                Assert.Throws<ArgumentException>(() => comp.Emit(output, metadataPEStream: metadataPeOutput,
                     options: EmitOptions.Default.WithEmitMetadataOnly(true)));
             }
         }
@@ -378,7 +378,7 @@ public void EmitMetadata_DisallowOutputtingNetModule()
             using (var output = new MemoryStream())
             using (var metadataPeOutput = new MemoryStream())
             {
-                Assert.Throws<ArgumentException>(() => comp.Emit(output, metadataPeStream: metadataPeOutput,
+                Assert.Throws<ArgumentException>(() => comp.Emit(output, metadataPEStream: metadataPeOutput,
                     options: EmitOptions.Default));
             }
         }
@@ -396,6 +396,46 @@ public void EmitMetadataOnly_DisallowOutputtingNetModule()
             }
         }
 
+        [Fact]
+        public void EmitMetadata_AllowEmbedding()
+        {
+            CSharpCompilation comp = CreateCompilation("", references: new[] { MscorlibRef },
+                options: TestOptions.DebugDll);
+
+            using (var output = new MemoryStream())
+            using (var metadataOutput = new MemoryStream())
+            {
+                var result = comp.Emit(output, metadataPEStream: metadataOutput,
+                    options: EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.Embedded));
+
+                VerifyEmbeddedDebugInfo(output, new[] { DebugDirectoryEntryType.CodeView, DebugDirectoryEntryType.EmbeddedPortablePdb });
+                VerifyEmbeddedDebugInfo(metadataOutput, new DebugDirectoryEntryType[] { });
+            }
+
+            void VerifyEmbeddedDebugInfo(MemoryStream stream, DebugDirectoryEntryType[] expected)
+            {
+                using (var peReader = new PEReader(stream.ToImmutable()))
+                {
+                    var entries = peReader.ReadDebugDirectory();
+                    AssertEx.Equal(expected, entries.Select(e => e.Type));
+                }
+            }
+        }
+
+        [Fact]
+        public void EmitMetadataOnly_DisallowEmbedding()
+        {
+            CSharpCompilation comp = CreateCompilation("", references: new[] { MscorlibRef },
+                options: TestOptions.DebugDll);
+
+            using (var output = new MemoryStream())
+            {
+                Assert.Throws<ArgumentException>(() => comp.Emit(output,
+                    options: EmitOptions.Default.WithEmitMetadataOnly(true)
+                        .WithDebugInformationFormat(DebugInformationFormat.Embedded)));
+            }
+        }
+
         [Fact]
         public void EmitMetadata()
         {
@@ -412,17 +452,17 @@ public abstract class PublicClass
             using (var pdbOutput = new MemoryStream())
             using (var metadataOutput = new MemoryStream())
             {
-                var result = comp.Emit(output, pdbOutput, metadataPeStream: metadataOutput);
+                var result = comp.Emit(output, pdbOutput, metadataPEStream: metadataOutput);
                 Assert.True(result.Success);
                 Assert.NotEqual(0, output.Position);
                 Assert.NotEqual(0, pdbOutput.Position);
                 Assert.NotEqual(0, metadataOutput.Position);
-                MetadataReaderUtils.VerifyMethodBodies(ImmutableArray.CreateRange(output.GetBuffer()), expectEmptyOrThrowNull: false);
-                MetadataReaderUtils.VerifyMethodBodies(ImmutableArray.CreateRange(metadataOutput.GetBuffer()), expectEmptyOrThrowNull: true);
+                MetadataReaderUtils.AssertNotThrowNull(ImmutableArray.CreateRange(output.GetBuffer()));
+                MetadataReaderUtils.AssertEmptyOrThrowNull(ImmutableArray.CreateRange(metadataOutput.GetBuffer()));
             }
 
             var peImage = comp.EmitToArray();
-            MetadataReaderUtils.VerifyMethodBodies(peImage, expectEmptyOrThrowNull: false);
+            MetadataReaderUtils.AssertNotThrowNull(peImage);
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
index 0f58cbbc5e97a..e398a4a895d2c 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
@@ -134,7 +134,7 @@ public void SymWriterErrors()
             {
                 var result = compilation.Emit(
                     peStream: peStream,
-                    metadataPeStream: null,
+                    metadataPEStream: null,
                     pdbStream: pdbStream,
                     xmlDocumentationStream: null,
                     cancellationToken: default(CancellationToken),
@@ -168,7 +168,7 @@ public void SymWriterErrors2()
             {
                 var result = compilation.Emit(
                     peStream: peStream,
-                    metadataPeStream: null,
+                    metadataPEStream: null,
                     pdbStream: pdbStream,
                     xmlDocumentationStream: null,
                     cancellationToken: default(CancellationToken),
@@ -202,7 +202,7 @@ public void SymWriterErrors3()
             {
                 var result = compilation.Emit(
                     peStream: peStream,
-                    metadataPeStream: null,
+                    metadataPEStream: null,
                     pdbStream: pdbStream,
                     xmlDocumentationStream: null,
                     cancellationToken: default(CancellationToken),
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
index 7dd8597b0b3b5..376bf146c519b 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
@@ -468,6 +468,15 @@ internal static string EmbeddedTextsRequirePortablePdb {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Embedding PDB is not allowed when emitting metadata..
+        /// </summary>
+        internal static string EmbeddingPdbUnexpectedWhenEmittingMetadata {
+            get {
+                return ResourceManager.GetString("EmbeddingPdbUnexpectedWhenEmittingMetadata", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to A key in the pathMap is empty..
         /// </summary>
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.resx b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
index 928a36ef445d3..54d4a21da6f75 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.resx
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
@@ -336,6 +336,9 @@
   <data name="MetadataPeStreamUnexpectedWhenEmittingMetadataOnly" xml:space="preserve">
     <value>Metadata PE stream should not be given when emitting metadata only.</value>
   </data>
+  <data name="EmbeddingPdbUnexpectedWhenEmittingMetadata" xml:space="preserve">
+    <value>Embedding PDB is not allowed when emitting metadata.</value>
+  </data>
   <data name="CannotTargetNetModuleWhenEmittingRefAssembly" xml:space="preserve">
     <value>Cannot target net module when emitting ref assembly.</value>
   </data>
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index bd987941fff36..daf5c278c980c 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -1987,7 +1987,7 @@ public EmitResult Emit(
                 debugEntryPoint,
                 sourceLinkStream,
                 embeddedTexts,
-                metadataPeStream: null,
+                metadataPEStream: null,
                 cancellationToken: cancellationToken);
         }
 
@@ -1995,7 +1995,7 @@ public EmitResult Emit(
         /// Emit the IL for the compiled source code into the specified stream.
         /// </summary>
         /// <param name="peStream">Stream to which the compilation will be written.</param>
-        /// <param name="metadataPeStream">Stream to which the metadata-only output will be written.</param>
+        /// <param name="metadataPEStream">Stream to which the metadata-only output will be written.</param>
         /// <param name="pdbStream">Stream to which the compilation's debug info will be written.  Null to forego PDB generation.</param>
         /// <param name="xmlDocumentationStream">Stream to which the compilation's XML documentation will be written.  Null to forego XML generation.</param>
         /// <param name="win32Resources">Stream from which the compilation's Win32 resources will be read (in RES format).  
@@ -2036,7 +2036,7 @@ public EmitResult Emit(
             IMethodSymbol debugEntryPoint = null,
             Stream sourceLinkStream = null,
             IEnumerable<EmbeddedText> embeddedTexts = null,
-            Stream metadataPeStream = null,
+            Stream metadataPEStream = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
             if (peStream == null)
@@ -2067,16 +2067,22 @@ public EmitResult Emit(
                 }
             }
 
-            if (metadataPeStream != null && options?.EmitMetadataOnly == true)
+            if (metadataPEStream != null && options?.EmitMetadataOnly == true)
             {
-                throw new ArgumentException(CodeAnalysisResources.MetadataPeStreamUnexpectedWhenEmittingMetadataOnly, nameof(metadataPeStream));
+                throw new ArgumentException(CodeAnalysisResources.MetadataPeStreamUnexpectedWhenEmittingMetadataOnly, nameof(metadataPEStream));
+            }
+
+            if (options?.DebugInformationFormat == DebugInformationFormat.Embedded &&
+                options?.EmitMetadataOnly == true)
+            {
+                throw new ArgumentException(CodeAnalysisResources.EmbeddingPdbUnexpectedWhenEmittingMetadata, nameof(metadataPEStream));
             }
 
             if (this.Options.OutputKind == OutputKind.NetModule)
             {
-                if (metadataPeStream != null)
+                if (metadataPEStream != null)
                 {
-                    throw new ArgumentException(CodeAnalysisResources.CannotTargetNetModuleWhenEmittingRefAssembly, nameof(metadataPeStream));
+                    throw new ArgumentException(CodeAnalysisResources.CannotTargetNetModuleWhenEmittingRefAssembly, nameof(metadataPEStream));
                 }
                 else if (options?.EmitMetadataOnly == true)
                 {
@@ -2119,7 +2125,7 @@ public EmitResult Emit(
 
             return Emit(
                 peStream,
-                metadataPeStream,
+                metadataPEStream,
                 pdbStream,
                 xmlDocumentationStream,
                 win32Resources,
@@ -2138,7 +2144,7 @@ public EmitResult Emit(
         /// </summary>
         internal EmitResult Emit(
             Stream peStream,
-            Stream metadataPeStream,
+            Stream metadataPEStream,
             Stream pdbStream,
             Stream xmlDocumentationStream,
             Stream win32Resources,
@@ -2206,7 +2212,7 @@ internal EmitResult Emit(
                     success = SerializeToPeStream(
                         moduleBeingBuilt,
                         new SimpleEmitStreamProvider(peStream),
-                        (metadataPeStream != null) ? new SimpleEmitStreamProvider(metadataPeStream) : null,
+                        (metadataPEStream != null) ? new SimpleEmitStreamProvider(metadataPEStream) : null,
                         (pdbStream != null) ? new SimpleEmitStreamProvider(pdbStream) : null,
                         testData?.SymWriterFactory,
                         diagnostics,
@@ -2373,7 +2379,7 @@ internal CommonPEModuleBuilder CheckOptionsAndCreateModuleBuilder(
         internal bool SerializeToPeStream(
             CommonPEModuleBuilder moduleBeingBuilt,
             EmitStreamProvider peStreamProvider,
-            EmitStreamProvider metadataPeStreamProvider,
+            EmitStreamProvider metadataPEStreamProvider,
             EmitStreamProvider pdbStreamProvider,
             Func<object> testSymWriterFactory,
             DiagnosticBag diagnostics,
@@ -2487,7 +2493,7 @@ internal bool SerializeToPeStream(
                 };
 
                 Func<Stream> getRefPeStream;
-                if (metadataPeStreamProvider != null)
+                if (metadataPEStreamProvider != null)
                 {
                     getRefPeStream = () =>
                     {
@@ -2496,7 +2502,7 @@ internal bool SerializeToPeStream(
                             return null;
                         }
 
-                        refPeStream = metadataPeStreamProvider.GetOrCreateStream(metadataDiagnostics);
+                        refPeStream = metadataPEStreamProvider.GetOrCreateStream(metadataDiagnostics);
                         Debug.Assert(refPeStream != null || metadataDiagnostics.HasAnyErrors());
                         return refPeStream;
                     };
@@ -2508,7 +2514,7 @@ internal bool SerializeToPeStream(
 
                 try
                 {
-                    if (Cci.PeWriter.WritePeToStream(
+                    if (SerializePeToStream(
                         new EmitContext(moduleBeingBuilt, null, metadataDiagnostics),
                         this.MessageProvider,
                         getPeStream,
@@ -2591,6 +2597,55 @@ internal bool SerializeToPeStream(
             return true;
         }
 
+        internal static bool SerializePeToStream(
+             EmitContext context,
+             CommonMessageProvider messageProvider,
+             Func<Stream> getPeStream,
+             Func<Stream> getMetadataPeStreamOpt,
+             Func<Stream> getPortablePdbStreamOpt,
+             Cci.PdbWriter nativePdbWriterOpt,
+             string pdbPathOpt,
+             bool metadataOnly,
+             bool isDeterministic,
+             CancellationToken cancellationToken)
+        {
+            if (!Cci.PeWriter.WritePeToStream(
+                context,
+                messageProvider,
+                getPeStream,
+                getPortablePdbStreamOpt,
+                nativePdbWriterOpt,
+                pdbPathOpt,
+                metadataOnly,
+                isDeterministic,
+                cancellationToken))
+            {
+                return false;
+            }
+
+            // produce the secondary output (ref assembly) if needed
+            if (getMetadataPeStreamOpt != null)
+            {
+                Debug.Assert(!metadataOnly);
+
+                if (!Cci.PeWriter.WritePeToStream(
+                    context,
+                    messageProvider,
+                    getMetadataPeStreamOpt,
+                    getPortablePdbStreamOpt: null,
+                    nativePdbWriterOpt: null,
+                    pdbPathOpt: null,
+                    metadataOnly: true,
+                    isDeterministic: isDeterministic,
+                    cancellationToken: cancellationToken))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         internal EmitBaseline SerializeToDeltaStreams(
             CommonPEModuleBuilder moduleBeingBuilt,
             EmitBaseline baseline,
diff --git a/src/Compilers/Core/Portable/PEWriter/FullMetadataWriter.cs b/src/Compilers/Core/Portable/PEWriter/FullMetadataWriter.cs
index 47e8694c2b927..11cfb2027b637 100644
--- a/src/Compilers/Core/Portable/PEWriter/FullMetadataWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/FullMetadataWriter.cs
@@ -51,7 +51,7 @@ public static MetadataWriter Create(
                     break;
 
                 case DebugInformationFormat.Embedded:
-                    debugBuilderOpt = new MetadataBuilder();
+                    debugBuilderOpt = metadataOnly ? null : new MetadataBuilder();
                     break;
 
                 default:
diff --git a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
index d54aee2c74a85..aeeb574e8dc7b 100644
--- a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
@@ -70,8 +70,13 @@ internal abstract partial class MetadataWriter
         // A map of method body before token translation to RVA. Used for deduplication of small bodies.
         private readonly Dictionary<ImmutableArray<byte>, int> _smallMethodBodies;
 
-        private static readonly ImmutableArray<byte> ThrowNullIL = ImmutableArray.Create((byte)ILOpCode.Ldnull, (byte)ILOpCode.Throw);
-        private const int ThrowNullMaxStack = 1;
+        private const byte TinyFormat = 2;
+        private const int ThrowNullCodeSize = 2;
+        private static readonly ImmutableArray<byte> ThrowNullEncodedBody =
+            ImmutableArray.Create(
+                (byte)((ThrowNullCodeSize << 2) | TinyFormat),
+                (byte)ILOpCode.Ldnull,
+                (byte)ILOpCode.Throw);
 
         protected MetadataWriter(
             MetadataBuilder metadata,
@@ -1785,7 +1790,9 @@ public void BuildMetadataAndIL(
                 }
             }
 
-            int[] methodBodyOffsets = SerializeMethodBodies(ilBuilder, nativePdbWriterOpt, out mvidStringFixup);
+            int[] methodBodyOffsets = MetadataOnly ?
+                SerializeThrowNullMethodBodies(ilBuilder, out mvidStringFixup) :
+                SerializeMethodBodies(ilBuilder, nativePdbWriterOpt, out mvidStringFixup);
 
             _cancellationToken.ThrowIfCancellationRequested();
 
@@ -2808,6 +2815,35 @@ private void PopulateStandaloneSignatures()
             }
         }
 
+        private int[] SerializeThrowNullMethodBodies(BlobBuilder ilBuilder, out Blob mvidStringFixup)
+        {
+            var methods = this.GetMethodDefs();
+            int[] bodyOffsets = new int[methods.Count];
+
+            int bodyOffsetCache = -1;
+            int methodRid = 0;
+            foreach (IMethodDefinition method in methods)
+            {
+                if (method.HasBody())
+                {
+                    if (bodyOffsetCache == -1)
+                    {
+                        bodyOffsetCache = ilBuilder.Count;
+                        ilBuilder.WriteBytes(ThrowNullEncodedBody);
+                    }
+                    bodyOffsets[methodRid] = bodyOffsetCache;
+                }
+                else
+                {
+                    bodyOffsets[methodRid] = -1;
+                }
+                methodRid++;
+            }
+
+            mvidStringFixup = default(Blob);
+            return bodyOffsets;
+        }
+
         private int[] SerializeMethodBodies(BlobBuilder ilBuilder, PdbWriter nativePdbWriterOpt, out Blob mvidStringFixup)
         {
             CustomDebugInfoWriter customDebugInfoWriter = (nativePdbWriterOpt != null) ? new CustomDebugInfoWriter(nativePdbWriterOpt) : null;
@@ -2833,30 +2869,21 @@ private int[] SerializeMethodBodies(BlobBuilder ilBuilder, PdbWriter nativePdbWr
 
                 if (method.HasBody())
                 {
-                    if (MetadataOnly)
+                    body = method.GetBody(Context);
+
+                    if (body != null)
                     {
-                        bodyOffset = SerializeThrowNullMethodBody(encoder);
-                        localSignatureHandleOpt = default(StandaloneSignatureHandle);
-                        body = null;
+                        localSignatureHandleOpt = this.SerializeLocalVariablesSignature(body);
+
+                        // TODO: consider parallelizing these (local signature tokens can be piped into IL serialization & debug info generation)
+                        bodyOffset = SerializeMethodBody(encoder, body, localSignatureHandleOpt, ref mvidStringHandle, ref mvidStringFixup);
+
+                        nativePdbWriterOpt?.SerializeDebugInfo(body, localSignatureHandleOpt, customDebugInfoWriter);
                     }
                     else
                     {
-                        body = method.GetBody(Context);
-
-                        if (body != null)
-                        {
-                            localSignatureHandleOpt = this.SerializeLocalVariablesSignature(body);
-
-                            // TODO: consider parallelizing these (local signature tokens can be piped into IL serialization & debug info generation)
-                            bodyOffset = SerializeMethodBody(encoder, body, localSignatureHandleOpt, ref mvidStringHandle, ref mvidStringFixup);
-
-                            nativePdbWriterOpt?.SerializeDebugInfo(body, localSignatureHandleOpt, customDebugInfoWriter);
-                        }
-                        else
-                        {
-                            bodyOffset = 0;
-                            localSignatureHandleOpt = default(StandaloneSignatureHandle);
-                        }
+                        bodyOffset = 0;
+                        localSignatureHandleOpt = default(StandaloneSignatureHandle);
                     }
                 }
                 else
@@ -2882,55 +2909,11 @@ private int[] SerializeMethodBodies(BlobBuilder ilBuilder, PdbWriter nativePdbWr
             return bodyOffsets;
         }
 
-        private int SerializeThrowNullMethodBody(MethodBodyStreamEncoder encoder)
-        {
-            UserStringHandle mvidStringHandle = default(UserStringHandle);
-            Blob mvidStringFixup = default(Blob);
-
-            int offset = SerializeMethodBody(
-                encoder,
-                ThrowNullIL,
-                ThrowNullMaxStack,
-                ImmutableArray<ExceptionHandlerRegion>.Empty,
-                default(StandaloneSignatureHandle),
-                MethodBodyAttributes.None,
-                ref mvidStringHandle,
-                ref mvidStringFixup);
-
-            Debug.Assert(mvidStringHandle.Equals(default(UserStringHandle)) && mvidStringFixup.Equals(default(Blob)));
-            return offset;
-        }
-
-        private int SerializeMethodBody(
-            MethodBodyStreamEncoder encoder,
-            IMethodBody methodBody,
-            StandaloneSignatureHandle localSignatureHandleOpt,
-            ref UserStringHandle mvidStringHandle,
-            ref Blob mvidStringFixup)
-        {
-            return SerializeMethodBody(
-                encoder,
-                methodBody.IL,
-                methodBody.MaxStack,
-                methodBody.ExceptionRegions,
-                localSignatureHandleOpt,
-                (methodBody.LocalsAreZeroed ? MethodBodyAttributes.InitLocals : MethodBodyAttributes.None),
-                ref mvidStringHandle,
-                ref mvidStringFixup);
-        }
-
-        private int SerializeMethodBody(
-            MethodBodyStreamEncoder encoder,
-            ImmutableArray<byte> il,
-            ushort maxStack,
-            ImmutableArray<ExceptionHandlerRegion> exceptionRegions,
-            StandaloneSignatureHandle localSignatureHandleOpt,
-            MethodBodyAttributes methodBodyAttributes,
-            ref UserStringHandle mvidStringHandle,
-            ref Blob mvidStringFixup)
-        {
-            int ilLength = il.Length;
-            bool isSmallBody = ilLength < 64 && maxStack <= 8 && localSignatureHandleOpt.IsNil && exceptionRegions.Length == 0;
+        private int SerializeMethodBody(MethodBodyStreamEncoder encoder, IMethodBody methodBody, StandaloneSignatureHandle localSignatureHandleOpt, ref UserStringHandle mvidStringHandle, ref Blob mvidStringFixup)
+        {
+            int ilLength = methodBody.IL.Length;
+            var exceptionRegions = methodBody.ExceptionRegions;
+            bool isSmallBody = ilLength < 64 && methodBody.MaxStack <= 8 && localSignatureHandleOpt.IsNil && exceptionRegions.Length == 0;
 
             // Check if an identical method body has already been serialized.
             // If so, use the RVA of the already serialized one.
@@ -2939,27 +2922,27 @@ private int SerializeMethodBody(
             // Don't do small body method caching during deterministic builds until this issue is fixed
             // https://github.com/dotnet/roslyn/issues/7595
             int bodyOffset;
-            if (!_deterministic && isSmallBody && _smallMethodBodies.TryGetValue(il, out bodyOffset))
+            if (!_deterministic && isSmallBody && _smallMethodBodies.TryGetValue(methodBody.IL, out bodyOffset))
             {
                 return bodyOffset;
             }
 
             var encodedBody = encoder.AddMethodBody(
-                codeSize: ilLength,
-                maxStack: maxStack,
+                codeSize: methodBody.IL.Length,
+                maxStack: methodBody.MaxStack,
                 exceptionRegionCount: exceptionRegions.Length,
                 hasSmallExceptionRegions: MayUseSmallExceptionHeaders(exceptionRegions),
                 localVariablesSignature: localSignatureHandleOpt,
-                attributes: methodBodyAttributes);
+                attributes: (methodBody.LocalsAreZeroed ? MethodBodyAttributes.InitLocals : 0));
 
             // Don't do small body method caching during deterministic builds until this issue is fixed
             // https://github.com/dotnet/roslyn/issues/7595
             if (isSmallBody && !_deterministic)
             {
-                _smallMethodBodies.Add(il, encodedBody.Offset);
+                _smallMethodBodies.Add(methodBody.IL, encodedBody.Offset);
             }
 
-            WriteInstructions(encodedBody.Instructions, il, ref mvidStringHandle, ref mvidStringFixup);
+            WriteInstructions(encodedBody.Instructions, methodBody.IL, ref mvidStringHandle, ref mvidStringFixup);
             SerializeMethodBodyExceptionHandlerTable(encodedBody.ExceptionRegions, exceptionRegions);
 
             return encodedBody.Offset;
diff --git a/src/Compilers/Core/Portable/PEWriter/PeWriter.cs b/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
index ab65cf637ea89..82fecdd4e60c6 100644
--- a/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
@@ -26,55 +26,6 @@ public PeWritingException(Exception inner)
 
     internal static class PeWriter
     {
-        internal static bool WritePeToStream(
-             EmitContext context,
-             CommonMessageProvider messageProvider,
-             Func<Stream> getPeStream,
-             Func<Stream> getMetadataPeStreamOpt,
-             Func<Stream> getPortablePdbStreamOpt,
-             PdbWriter nativePdbWriterOpt,
-             string pdbPathOpt,
-             bool metadataOnly,
-             bool isDeterministic,
-             CancellationToken cancellationToken)
-        {
-            if (!WritePeToStream(
-                context,
-                messageProvider,
-                getPeStream,
-                getPortablePdbStreamOpt,
-                nativePdbWriterOpt,
-                pdbPathOpt,
-                metadataOnly,
-                isDeterministic,
-                cancellationToken))
-            {
-                return false;
-            }
-
-            // produce the secondary output (ref assembly) if needed
-            if (getMetadataPeStreamOpt != null)
-            {
-                Debug.Assert(!metadataOnly);
-
-                if (!WritePeToStream(
-                    context,
-                    messageProvider,
-                    getMetadataPeStreamOpt,
-                    getPortablePdbStreamOpt: null,
-                    nativePdbWriterOpt: null,
-                    pdbPathOpt: null,
-                    metadataOnly: true,
-                    isDeterministic: isDeterministic,
-                    cancellationToken: cancellationToken))
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
         internal static bool WritePeToStream(
             EmitContext context,
             CommonMessageProvider messageProvider,
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index 0ab3897d2d10c..d3935e7a9c429 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -15,7 +15,7 @@ Microsoft.CodeAnalysis.Compilation.CreateAnonymousTypeSymbol(System.Collections.
 Microsoft.CodeAnalysis.Compilation.CreateErrorNamespaceSymbol(Microsoft.CodeAnalysis.INamespaceSymbol container, string name) -> Microsoft.CodeAnalysis.INamespaceSymbol
 Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(Microsoft.CodeAnalysis.INamedTypeSymbol underlyingType, System.Collections.Immutable.ImmutableArray<string> elementNames = default(System.Collections.Immutable.ImmutableArray<string>), System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Location> elementLocations = default(System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Location>)) -> Microsoft.CodeAnalysis.INamedTypeSymbol
 Microsoft.CodeAnalysis.Compilation.CreateTupleTypeSymbol(System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ITypeSymbol> elementTypes, System.Collections.Immutable.ImmutableArray<string> elementNames = default(System.Collections.Immutable.ImmutableArray<string>), System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Location> elementLocations = default(System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Location>)) -> Microsoft.CodeAnalysis.INamedTypeSymbol
-Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream peStream, System.IO.Stream pdbStream = null, System.IO.Stream xmlDocumentationStream = null, System.IO.Stream win32Resources = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ResourceDescription> manifestResources = null, Microsoft.CodeAnalysis.Emit.EmitOptions options = null, Microsoft.CodeAnalysis.IMethodSymbol debugEntryPoint = null, System.IO.Stream sourceLinkStream = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.EmbeddedText> embeddedTexts = null, System.IO.Stream metadataPeStream = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Emit.EmitResult
+Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream peStream, System.IO.Stream pdbStream = null, System.IO.Stream xmlDocumentationStream = null, System.IO.Stream win32Resources = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ResourceDescription> manifestResources = null, Microsoft.CodeAnalysis.Emit.EmitOptions options = null, Microsoft.CodeAnalysis.IMethodSymbol debugEntryPoint = null, System.IO.Stream sourceLinkStream = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.EmbeddedText> embeddedTexts = null, System.IO.Stream metadataPEStream = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Emit.EmitResult
 Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream peStream, System.IO.Stream pdbStream, System.IO.Stream xmlDocumentationStream, System.IO.Stream win32Resources, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ResourceDescription> manifestResources, Microsoft.CodeAnalysis.Emit.EmitOptions options, Microsoft.CodeAnalysis.IMethodSymbol debugEntryPoint, System.IO.Stream sourceLinkStream, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.EmbeddedText> embeddedTexts, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.Emit.EmitResult
 Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream peStream, System.IO.Stream pdbStream, System.IO.Stream xmlDocumentationStream, System.IO.Stream win32Resources, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ResourceDescription> manifestResources, Microsoft.CodeAnalysis.Emit.EmitOptions options, Microsoft.CodeAnalysis.IMethodSymbol debugEntryPoint, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.Emit.EmitResult
 Microsoft.CodeAnalysis.Compilation.GetUnreferencedAssemblyIdentities(Microsoft.CodeAnalysis.Diagnostic diagnostic) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.AssemblyIdentity>
diff --git a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
index b8488f24edd3b..2e59edc2fae68 100644
--- a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
+++ b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
@@ -1413,7 +1413,7 @@ lVbRuntimePlus:
                 .ScriptArguments = scriptArgs.AsImmutableOrEmpty(),
                 .TouchedFilesPath = touchedFilesPath,
                 .OutputLevel = outputLevel,
-                .EmitPdb = emitPdb AndAlso Not metadataOnly,
+                .EmitPdb = emitPdb AndAlso Not metadataOnly, ' Silently ignore emitPdb when metadataOnly is set
                 .SourceLink = sourceLink,
                 .DefaultCoreLibraryReference = defaultCoreLibraryReference,
                 .PreferredUILang = preferredUILang,
diff --git a/src/Compilers/VisualBasic/Portable/VBResources.resx b/src/Compilers/VisualBasic/Portable/VBResources.resx
index 6be940646c748..4070f5e43e51e 100644
--- a/src/Compilers/VisualBasic/Portable/VBResources.resx
+++ b/src/Compilers/VisualBasic/Portable/VBResources.resx
@@ -5061,6 +5061,7 @@
 /target:winmdobj                  Create a Windows Metadata intermediate file
 /doc[+|-]                         Generates XML documentation file.
 /doc:&lt;file&gt;                       Generates XML documentation file to &lt;file&gt;.
+/refout:&lt;file&gt;                    Reference assembly output to generate
 
                                   - INPUT FILES -
 /addmodule:&lt;file_list&gt;            Reference metadata from the specified modules
@@ -5105,6 +5106,7 @@
                                   the target .dll or .exe.
 /deterministic                    Produce a deterministic assembly
                                   (including module version GUID and timestamp)
+/refonly                          Produce a reference assembly in place of the main output
 /instrument:TestCoverage          Produce an assembly instrumented to collect
                                   coverage information
 /sourcelink:&lt;file&gt;                Source link info to embed into Portable PDB.
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
index 775744fdbbce5..b94de992431c0 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
@@ -441,7 +441,7 @@ End Class"
                     "System.Diagnostics.DebuggableAttribute"})
 
             Dim peImage = comp.EmitToArray(emitRefOnly)
-            MetadataReaderUtils.VerifyMethodBodies(peImage, expectEmptyOrThrowNull:=True)
+            MetadataReaderUtils.AssertEmptyOrThrowNull(peImage)
         End Sub
 
         <Fact>
@@ -464,7 +464,7 @@ End Class"
 
             Using output As New MemoryStream()
                 Using metadataPeOutput As New MemoryStream()
-                    Assert.Throws(Of ArgumentException)(Function() comp.Emit(output, metadataPeStream:=metadataPeOutput,
+                    Assert.Throws(Of ArgumentException)(Function() comp.Emit(output, metadataPEStream:=metadataPeOutput,
                                         options:=EmitOptions.Default.WithEmitMetadataOnly(True)))
                 End Using
             End Using
@@ -484,19 +484,19 @@ End Class "
             Using output As New MemoryStream()
                 Using pdbOutput As New MemoryStream()
                     Using metadataOutput As New MemoryStream()
-                        Dim result = comp.Emit(output, pdbOutput, metadataPeStream:=metadataOutput)
+                        Dim result = comp.Emit(output, pdbOutput, metadataPEStream:=metadataOutput)
                         Assert.True(result.Success)
                         Assert.NotEqual(0, output.Position)
                         Assert.NotEqual(0, pdbOutput.Position)
                         Assert.NotEqual(0, metadataOutput.Position)
-                        MetadataReaderUtils.VerifyMethodBodies(ImmutableArray.CreateRange(output.GetBuffer()), expectEmptyOrThrowNull:=False)
-                        MetadataReaderUtils.VerifyMethodBodies(ImmutableArray.CreateRange(metadataOutput.GetBuffer()), expectEmptyOrThrowNull:=True)
+                        MetadataReaderUtils.AssertNotThrowNull(ImmutableArray.CreateRange(output.GetBuffer()))
+                        MetadataReaderUtils.AssertEmptyOrThrowNull(ImmutableArray.CreateRange(metadataOutput.GetBuffer()))
                     End Using
                 End Using
             End Using
 
             Dim peImage = comp.EmitToArray()
-            MetadataReaderUtils.VerifyMethodBodies(peImage, expectEmptyOrThrowNull:=False)
+            MetadataReaderUtils.AssertNotThrowNull(peImage)
         End Sub
 
         <WorkItem(4344, "DevDiv_Projects/Roslyn")>
diff --git a/src/Test/Utilities/Portable/Compilation/CompilationExtensions.cs b/src/Test/Utilities/Portable/Compilation/CompilationExtensions.cs
index c978fe782407b..04f0259cd29e6 100644
--- a/src/Test/Utilities/Portable/Compilation/CompilationExtensions.cs
+++ b/src/Test/Utilities/Portable/Compilation/CompilationExtensions.cs
@@ -47,7 +47,7 @@ internal static ImmutableArray<byte> EmitToArray(
 
             var emitResult = compilation.Emit(
                 peStream: peStream,
-                metadataPeStream: null,
+                metadataPEStream: null,
                 pdbStream: pdbStream,
                 xmlDocumentationStream: null,
                 win32Resources: null,
diff --git a/src/Test/Utilities/Portable/Compilation/IRuntimeEnvironment.cs b/src/Test/Utilities/Portable/Compilation/IRuntimeEnvironment.cs
index b767804c589bb..11f8042172152 100644
--- a/src/Test/Utilities/Portable/Compilation/IRuntimeEnvironment.cs
+++ b/src/Test/Utilities/Portable/Compilation/IRuntimeEnvironment.cs
@@ -235,7 +235,7 @@ EmitOptions emitOptions
                 {
                     result = compilation.Emit(
                         executableStream,
-                        metadataPeStream: null,
+                        metadataPEStream: null,
                         pdbStream: pdbStream,
                         xmlDocumentationStream: null,
                         win32Resources: null,
diff --git a/src/Test/Utilities/Portable/Metadata/MetadataReaderUtils.cs b/src/Test/Utilities/Portable/Metadata/MetadataReaderUtils.cs
index 5e1f8db49ddf5..f5d30937337f8 100644
--- a/src/Test/Utilities/Portable/Metadata/MetadataReaderUtils.cs
+++ b/src/Test/Utilities/Portable/Metadata/MetadataReaderUtils.cs
@@ -284,59 +284,37 @@ private sealed class ConstantSignatureVisualizer : ISignatureTypeProvider<string
             public static readonly ConstantSignatureVisualizer Instance = new ConstantSignatureVisualizer();
 
             public string GetArrayType(string elementType, ArrayShape shape)
-            {
-                return elementType + "[" + new string(',', shape.Rank) + "]";
-            }
+                => elementType + "[" + new string(',', shape.Rank) + "]";
 
             public string GetByReferenceType(string elementType)
-            {
-                return elementType + "&";
-            }
+                => elementType + "&";
 
             public string GetFunctionPointerType(MethodSignature<string> signature)
-            {
-                return "method-ptr";
-            }
+                => "method-ptr";
 
             public string GetGenericInstantiation(string genericType, ImmutableArray<string> typeArguments)
-            {
-                return genericType + "{" + string.Join(", ", typeArguments) + "}";
-            }
+                => genericType + "{" + string.Join(", ", typeArguments) + "}";
 
             public string GetGenericMethodParameter(object genericContext, int index)
-            {
-                return "!!" + index;
-            }
+                => "!!" + index;
 
             public string GetGenericTypeParameter(object genericContext, int index)
-            {
-                return "!" + index;
-            }
+                => "!" + index;
 
             public string GetModifiedType(string modifier, string unmodifiedType, bool isRequired)
-            {
-                return (isRequired ? "modreq" : "modopt") + "(" + modifier + ") " + unmodifiedType;
-            }
+                => (isRequired ? "modreq" : "modopt") + "(" + modifier + ") " + unmodifiedType;
 
             public string GetPinnedType(string elementType)
-            {
-                return "pinned " + elementType;
-            }
+                => "pinned " + elementType;
 
             public string GetPointerType(string elementType)
-            {
-                return elementType + "*";
-            }
+                => elementType + "*";
 
             public string GetPrimitiveType(PrimitiveTypeCode typeCode)
-            {
-                return typeCode.ToString();
-            }
+                => typeCode.ToString();
 
             public string GetSZArrayType(string elementType)
-            {
-                return elementType + "[]";
-            }
+                => elementType + "[]";
 
             public string GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind)
             {
@@ -378,11 +356,7 @@ internal static void VerifyPEMetadata(string pePath, string[] types, string[] me
             }
         }
 
-        /// <summary>
-        /// Asserts that all the method bodies in the PE are empty or `throw null`, if expectEmptyOrThrowNull is true.
-        /// Asserts that none of the methods bodies are empty or `throw null`, if expectEmptyOrThrowNull is false.
-        /// </summary>
-        internal static void VerifyMethodBodies(ImmutableArray<byte> peImage, bool expectEmptyOrThrowNull)
+        internal static void VerifyMethodBodies(ImmutableArray<byte> peImage, Action<byte[]> ilValidator)
         {
             using (var peReader = new PEReader(peImage))
             {
@@ -393,19 +367,38 @@ internal static void VerifyMethodBodies(ImmutableArray<byte> peImage, bool expec
                     if (rva != 0)
                     {
                         var il = peReader.GetMethodBody(rva).GetILBytes();
-                        var throwNull = new[] { (byte)ILOpCode.Ldnull, (byte)ILOpCode.Throw };
-
-                        if (expectEmptyOrThrowNull)
-                        {
-                            AssertEx.Equal(throwNull, il);
-                        }
-                        else
-                        {
-                            AssertEx.NotEqual(throwNull, il);
-                        }
+                        ilValidator(il);
+                    }
+                    else
+                    {
+                        ilValidator(null);
                     }
                 }
             }
         }
+
+        static readonly byte[] ThrowNull = new[] { (byte)ILOpCode.Ldnull, (byte)ILOpCode.Throw };
+
+        internal static void AssertEmptyOrThrowNull(ImmutableArray<byte> peImage)
+        {
+            VerifyMethodBodies(peImage, (il) =>
+            {
+                if (il != null)
+                {
+                    AssertEx.Equal(ThrowNull, il);
+                }
+            });
+        }
+
+        internal static void AssertNotThrowNull(ImmutableArray<byte> peImage)
+        {
+            VerifyMethodBodies(peImage, (il) =>
+            {
+                if (il != null)
+                {
+                    AssertEx.NotEqual(ThrowNull, il);
+                }
+            });
+        }
     }
 }

From 9d9de026c519d3414f99d1154beb860569ab8273 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Fri, 24 Mar 2017 23:05:58 -0700
Subject: [PATCH 008/284] Add ref output to CoreCompile target and add
 CopyRefAssembly task (#18058)

---
 .../Core/MSBuildTask/CopyRefAssembly.cs       | 95 +++++++++++++++++++
 .../Core/MSBuildTask/ErrorString.Designer.cs  | 46 +++++++--
 .../Core/MSBuildTask/ErrorString.resx         | 10 ++
 .../Core/MSBuildTask/MSBuildTask.csproj       |  1 +
 .../Core/MSBuildTask/ManagedCompiler.cs       |  7 +-
 .../MSBuildTask/Microsoft.CSharp.Core.targets |  2 +
 .../Microsoft.VisualBasic.Core.targets        |  2 +
 src/Compilers/Core/MSBuildTask/project.json   |  1 +
 .../MSBuildTaskTests/MSBuildTaskTests.csproj  |  2 +-
 9 files changed, 155 insertions(+), 11 deletions(-)
 create mode 100644 src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs

diff --git a/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs b/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs
new file mode 100644
index 0000000000000..cdb32fa7adf59
--- /dev/null
+++ b/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs
@@ -0,0 +1,95 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.IO;
+using System.Reflection.Metadata;
+using System.Reflection.PortableExecutable;
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+
+namespace Microsoft.CodeAnalysis.BuildTasks
+{
+    /// <summary>
+    /// If the source and destination ref assemblies are different,
+    /// this task copies the source over to the destination.
+    /// </summary>
+    public class CopyRefAssembly : Task
+    {
+        [Required]
+        public string SourcePath { get; set; }
+
+        [Output]
+        [Required]
+        public string DestinationPath { get; set; }
+
+        public CopyRefAssembly()
+        {
+            TaskResources = ErrorString.ResourceManager;
+        }
+
+        public override bool Execute()
+        {
+            if (!File.Exists(SourcePath))
+            {
+                Log.LogErrorWithCodeFromResources("General_ExpectedFileMissing", SourcePath);
+                return false;
+            }
+
+            if (File.Exists(DestinationPath))
+            {
+                Guid source;
+                try
+                {
+                    source = ExtractMvid(SourcePath);
+                }
+                catch (Exception e)
+                {
+                    Log.LogMessageFromResources(MessageImportance.High, "CopyRefAssembly_BadSource3", SourcePath, e.Message, e.StackTrace);
+                }
+
+                try
+                {
+                    Guid destination = ExtractMvid(DestinationPath);
+
+                    if (source.Equals(destination))
+                    {
+                        Log.LogMessageFromResources(MessageImportance.Low, "CopyRefAssembly_SkippingCopy1", DestinationPath);
+                        return true;
+                    }
+                }
+                catch (Exception)
+                {
+                    Log.LogMessage(MessageImportance.High, "CopyRefAssembly_BadDestination1", DestinationPath);
+                }
+            }
+
+            return Copy();
+        }
+
+        private bool Copy()
+        {
+            try
+            {
+                File.Copy(SourcePath, DestinationPath, overwrite: true);
+            }
+            catch (Exception e)
+            {
+                Log.LogErrorWithCodeFromResources("Compiler_UnexpectedException");
+                ManagedCompiler.LogErrorOutput(e.ToString(), Log);
+                return false;
+            }
+
+            return true;
+        }
+
+        private Guid ExtractMvid(string path)
+        {
+            using (FileStream source = File.OpenRead(path))
+            using (var reader = new PEReader(source))
+            {
+                var metadataReader = reader.GetMetadataReader();
+                return metadataReader.GetGuid(metadataReader.GetModuleDefinition().Mvid);
+            }
+        }
+    }
+}
diff --git a/src/Compilers/Core/MSBuildTask/ErrorString.Designer.cs b/src/Compilers/Core/MSBuildTask/ErrorString.Designer.cs
index 26a69b7f2a1c7..560a55decf577 100644
--- a/src/Compilers/Core/MSBuildTask/ErrorString.Designer.cs
+++ b/src/Compilers/Core/MSBuildTask/ErrorString.Designer.cs
@@ -70,6 +70,34 @@ internal static string Compiler_UnexpectedException {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Failed to check the content hash of the destination ref assembly &apos;{0}&apos;. It will be overwritten..
+        /// </summary>
+        internal static string CopyRefAssembly_BadDestination1 {
+            get {
+                return ResourceManager.GetString("CopyRefAssembly_BadDestination1", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Failed to check the content hash of the source ref assembly &apos;{0}&apos;: {1}
+        ///{2}.
+        /// </summary>
+        internal static string CopyRefAssembly_BadSource3 {
+            get {
+                return ResourceManager.GetString("CopyRefAssembly_BadSource3", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Reference assembly &quot;{0}&quot; already has latest information. Leaving it untouched..
+        /// </summary>
+        internal static string CopyRefAssembly_SkippingCopy1 {
+            get {
+                return ResourceManager.GetString("CopyRefAssembly_SkippingCopy1", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to MSB3053: The assembly alias &quot;{1}&quot; on reference &quot;{0}&quot; contains illegal characters..
         /// </summary>
@@ -142,15 +170,6 @@ internal static string General_ExpectedFileMissing {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to MSB3082: Task failed because &quot;{0}&quot; was not found..
-        /// </summary>
-        internal static string General_ToolFileNotFound {
-            get {
-                return ResourceManager.GetString("General_ToolFileNotFound", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to MSB3087: An incompatible host object was passed into the &quot;{0}&quot; task.  The host object for this task must implement the &quot;{1}&quot; interface..
         /// </summary>
@@ -187,6 +206,15 @@ internal static string General_ReferenceDoesNotExist {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to MSB3082: Task failed because &quot;{0}&quot; was not found..
+        /// </summary>
+        internal static string General_ToolFileNotFound {
+            get {
+                return ResourceManager.GetString("General_ToolFileNotFound", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Shared compilation failed; falling back to tool: {0}.
         /// </summary>
diff --git a/src/Compilers/Core/MSBuildTask/ErrorString.resx b/src/Compilers/Core/MSBuildTask/ErrorString.resx
index 66b362aa34636..9f6962ded7d75 100644
--- a/src/Compilers/Core/MSBuildTask/ErrorString.resx
+++ b/src/Compilers/Core/MSBuildTask/ErrorString.resx
@@ -151,6 +151,16 @@
   <data name="General_ExpectedFileMissing" xml:space="preserve">
     <value>Expected file "{0}" does not exist.</value>
   </data>
+  <data name="CopyRefAssembly_SkippingCopy1" xml:space="preserve">
+    <value>Reference assembly "{0}" already has latest information. Leaving it untouched.</value>
+  </data>
+  <data name="CopyRefAssembly_BadSource3" xml:space="preserve">
+    <value>Failed to check the content hash of the source ref assembly '{0}': {1}
+{2}</value>
+  </data>
+  <data name="CopyRefAssembly_BadDestination1" xml:space="preserve">
+    <value>Failed to check the content hash of the destination ref assembly '{0}'. It will be overwritten.</value>
+  </data>
   <data name="General_ToolFileNotFound" xml:space="preserve">
     <value>MSB3082: Task failed because "{0}" was not found.</value>
     <comment>{StrBegin="MSB3082: "}</comment>
diff --git a/src/Compilers/Core/MSBuildTask/MSBuildTask.csproj b/src/Compilers/Core/MSBuildTask/MSBuildTask.csproj
index d9b7f527e3756..cbced79b1b505 100644
--- a/src/Compilers/Core/MSBuildTask/MSBuildTask.csproj
+++ b/src/Compilers/Core/MSBuildTask/MSBuildTask.csproj
@@ -55,6 +55,7 @@
     </Compile>
     <Compile Include="AssemblyResolution.cs" />
     <Compile Include="CanonicalError.cs" />
+    <Compile Include="CopyRefAssembly.cs" />
     <Compile Include="ValidateBootstrap.cs" />
     <Compile Include="CommandLineBuilderExtension.cs" />
     <Compile Include="Csc.cs" />
diff --git a/src/Compilers/Core/MSBuildTask/ManagedCompiler.cs b/src/Compilers/Core/MSBuildTask/ManagedCompiler.cs
index a72cdd6b1281c..908e82078ee6a 100644
--- a/src/Compilers/Core/MSBuildTask/ManagedCompiler.cs
+++ b/src/Compilers/Core/MSBuildTask/ManagedCompiler.cs
@@ -591,6 +591,11 @@ private int HandleResponse(BuildResponse response, string pathToTool, string res
         }
 
         private void LogErrorOutput(string output)
+        {
+            LogErrorOutput(output, Log);
+        }
+
+        internal static void LogErrorOutput(string output, TaskLoggingHelper log)
         {
             string[] lines = output.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
             foreach (string line in lines)
@@ -598,7 +603,7 @@ private void LogErrorOutput(string output)
                 string trimmedMessage = line.Trim();
                 if (trimmedMessage != "")
                 {
-                    Log.LogError(trimmedMessage);
+                    log.LogError(trimmedMessage);
                 }
             }
         }
diff --git a/src/Compilers/Core/MSBuildTask/Microsoft.CSharp.Core.targets b/src/Compilers/Core/MSBuildTask/Microsoft.CSharp.Core.targets
index 67a2aeb9cbe05..5612c758c3d68 100644
--- a/src/Compilers/Core/MSBuildTask/Microsoft.CSharp.Core.targets
+++ b/src/Compilers/Core/MSBuildTask/Microsoft.CSharp.Core.targets
@@ -19,6 +19,7 @@
                   @(EmbeddedFiles)"
           Outputs="@(DocFileItem);
                    @(IntermediateAssembly);
+                   @(IntermediateRefAssembly);
                    @(_DebugSymbolsIntermediatePath);
                    $(NonExistentFile);
                    @(CustomAdditionalCompileOutputs)"
@@ -110,6 +111,7 @@
          Deterministic="$(Deterministic)"
          PublicSign="$(PublicSign)"
          OutputAssembly="@(IntermediateAssembly)"
+         OutputRefAssembly="@(IntermediateRefAssembly)"
          PdbFile="$(PdbFile)"
          Platform="$(PlatformTarget)"
          Prefer32Bit="$(Prefer32Bit)"
diff --git a/src/Compilers/Core/MSBuildTask/Microsoft.VisualBasic.Core.targets b/src/Compilers/Core/MSBuildTask/Microsoft.VisualBasic.Core.targets
index 4ead670434c75..eef272a4b8c59 100644
--- a/src/Compilers/Core/MSBuildTask/Microsoft.VisualBasic.Core.targets
+++ b/src/Compilers/Core/MSBuildTask/Microsoft.VisualBasic.Core.targets
@@ -19,6 +19,7 @@
                   @(EmbeddedFiles)"
           Outputs="@(DocFileItem);
                    @(IntermediateAssembly);
+                   @(IntermediateRefAssembly);
                    @(_DebugSymbolsIntermediatePath);
                    $(NonExistentFile);
                    @(CustomAdditionalCompileOutputs)"
@@ -102,6 +103,7 @@
          OptionStrict="$(OptionStrict)"
          OptionStrictType="$(OptionStrictType)"
          OutputAssembly="@(IntermediateAssembly)"
+         OutputRefAssembly="@(IntermediateRefAssembly)"
          PdbFile="$(PdbFile)"
          Platform="$(PlatformTarget)"
          Prefer32Bit="$(Prefer32Bit)"
diff --git a/src/Compilers/Core/MSBuildTask/project.json b/src/Compilers/Core/MSBuildTask/project.json
index ac0c51a5b3082..c9efa1ac00175 100644
--- a/src/Compilers/Core/MSBuildTask/project.json
+++ b/src/Compilers/Core/MSBuildTask/project.json
@@ -15,6 +15,7 @@
     "System.IO.Pipes": "4.3.0",
     "System.Linq": "4.3.0",
     "System.Reflection": "4.3.0",
+    "System.Reflection.Metadata": "1.4.2",
     "System.Security.AccessControl": "4.3.0",
     "System.Security.Cryptography.Algorithms": "4.3.0",
     "System.Security.Principal.Windows": "4.3.0",
diff --git a/src/Compilers/Core/MSBuildTaskTests/MSBuildTaskTests.csproj b/src/Compilers/Core/MSBuildTaskTests/MSBuildTaskTests.csproj
index 47f5b10b77665..73577163a49fe 100644
--- a/src/Compilers/Core/MSBuildTaskTests/MSBuildTaskTests.csproj
+++ b/src/Compilers/Core/MSBuildTaskTests/MSBuildTaskTests.csproj
@@ -77,4 +77,4 @@
     <None Include="project.json" />
   </ItemGroup>
   <Import Project="..\..\..\..\build\Targets\Imports.targets" />
-</Project>
+</Project>
\ No newline at end of file

From b3243e8691ec2b97dc0b17f5fef76ad2626aa7a1 Mon Sep 17 00:00:00 2001
From: Ty Overby <ty@pre-alpha.com>
Date: Fri, 31 Mar 2017 09:57:44 -0700
Subject: [PATCH 009/284] enable main methods to be asynchronous (#18157)

* enable main methods to be asynchronous

* add cref to documentation

* fix doc comment syntax

* remove message from resx

* move comments

* add async int test

* add more test

* re-add errors for pre-71 compilers

* add tests for previous versions of csharp

* add feature detection

* Disallow ref returning Main method

The Main method cannot have a ref return.

closes #17923

* add ref tests, add prototype comment

* change prototype comment
---
 .../Portable/CSharpResources.Designer.cs      |   9 +
 .../CSharp/Portable/CSharpResources.resx      |   3 +
 .../Portable/Compilation/CSharpCompilation.cs |  66 +--
 .../CSharp/Portable/Errors/ErrorCode.cs       |   2 +-
 .../CSharp/Portable/Errors/MessageID.cs       |   5 +
 .../CSharp/Portable/Symbols/MethodSymbol.cs   |  84 ++--
 .../CSharp/Test/Emit/Emit/EntryPointTests.cs  |  40 ++
 .../Semantic/Semantics/BindingAsyncTests.cs   | 389 ++++++++++++++++--
 8 files changed, 505 insertions(+), 93 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
index b2d5452c58a30..474abc016d6cf 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
+++ b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
@@ -9872,6 +9872,15 @@ internal static string IDS_FeatureAsync {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to async main.
+        /// </summary>
+        internal static string IDS_FeatureAsyncMain {
+            get {
+                return ResourceManager.GetString("IDS_FeatureAsyncMain", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to automatically implemented properties.
         /// </summary>
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index b97e92c32b452..c5f5ed764a3c4 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -5041,4 +5041,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_VoidAssignment" xml:space="preserve">
     <value>A value of type 'void' may not be assigned.</value>
   </data>
+  <data name="IDS_FeatureAsyncMain" xml:space="preserve">
+    <value>async main</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index a163e9ecc6b49..dc84d30bf09d2 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
@@ -19,6 +19,7 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.Symbols;
+using static Microsoft.CodeAnalysis.CSharp.Binder;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
@@ -40,7 +41,7 @@ public sealed partial class CSharpCompilation : Compilation
         // version. Do not make any changes to the public interface without making the corresponding
         // change to the VB version.
         //
-        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
+        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
         internal static readonly ParallelOptions DefaultParallelOptions = new ParallelOptions();
 
@@ -93,9 +94,9 @@ internal Conversions Conversions
         /// <summary>
         /// Holds onto data related to reference binding.
         /// The manager is shared among multiple compilations that we expect to have the same result of reference binding.
-        /// In most cases this can be determined without performing the binding. If the compilation however contains a circular 
+        /// In most cases this can be determined without performing the binding. If the compilation however contains a circular
         /// metadata reference (a metadata reference that refers back to the compilation) we need to avoid sharing of the binding results.
-        /// We do so by creating a new reference manager for such compilation. 
+        /// We do so by creating a new reference manager for such compilation.
         /// </summary>
         private ReferenceManager _referenceManager;
 
@@ -128,7 +129,7 @@ public override bool IsCaseSensitive
         }
 
         /// <summary>
-        /// The options the compilation was created with. 
+        /// The options the compilation was created with.
         /// </summary>
         public new CSharpCompilationOptions Options
         {
@@ -172,14 +173,14 @@ public LanguageVersion LanguageVersion
         protected override INamedTypeSymbol CommonCreateErrorTypeSymbol(INamespaceOrTypeSymbol container, string name, int arity)
         {
             return new ExtendedErrorTypeSymbol(
-                       container.EnsureCSharpSymbolOrNull<INamespaceOrTypeSymbol, NamespaceOrTypeSymbol>(nameof(container)), 
+                       container.EnsureCSharpSymbolOrNull<INamespaceOrTypeSymbol, NamespaceOrTypeSymbol>(nameof(container)),
                        name, arity, errorInfo: null);
         }
 
         protected override INamespaceSymbol CommonCreateErrorNamespaceSymbol(INamespaceSymbol container, string name)
         {
             return new MissingNamespaceSymbol(
-                       container.EnsureCSharpSymbolOrNull<INamespaceSymbol, NamespaceSymbol>(nameof(container)), 
+                       container.EnsureCSharpSymbolOrNull<INamespaceSymbol, NamespaceSymbol>(nameof(container)),
                        name);
         }
 
@@ -408,8 +409,8 @@ private CSharpCompilation Update(
         /// </summary>
         public new CSharpCompilation WithAssemblyName(string assemblyName)
         {
-            // Can't reuse references since the source assembly name changed and the referenced symbols might 
-            // have internals-visible-to relationship with this compilation or they might had a circular reference 
+            // Can't reuse references since the source assembly name changed and the referenced symbols might
+            // have internals-visible-to relationship with this compilation or they might had a circular reference
             // to this compilation.
 
             return new CSharpCompilation(
@@ -429,9 +430,9 @@ private CSharpCompilation Update(
         /// Creates a new compilation with the specified references.
         /// </summary>
         /// <remarks>
-        /// The new <see cref="CSharpCompilation"/> will query the given <see cref="MetadataReference"/> for the underlying 
-        /// metadata as soon as the are needed. 
-        /// 
+        /// The new <see cref="CSharpCompilation"/> will query the given <see cref="MetadataReference"/> for the underlying
+        /// metadata as soon as the are needed.
+        ///
         /// The new compilation uses whatever metadata is currently being provided by the <see cref="MetadataReference"/>.
         /// E.g. if the current compilation references a metadata file that has changed since the creation of the compilation
         /// the new compilation is going to use the updated version, while the current compilation will be using the previous (it doesn't change).
@@ -684,7 +685,7 @@ internal override bool HasSubmissionResult()
 
         /// <summary>
         /// Creates a new compilation without the specified syntax trees. Preserves metadata info for use with trees
-        /// added later. 
+        /// added later.
         /// </summary>
         public new CSharpCompilation RemoveSyntaxTrees(params SyntaxTree[] trees)
         {
@@ -693,7 +694,7 @@ internal override bool HasSubmissionResult()
 
         /// <summary>
         /// Creates a new compilation without the specified syntax trees. Preserves metadata info for use with trees
-        /// added later. 
+        /// added later.
         /// </summary>
         public new CSharpCompilation RemoveSyntaxTrees(IEnumerable<SyntaxTree> trees)
         {
@@ -746,7 +747,7 @@ internal override bool HasSubmissionResult()
 
         /// <summary>
         /// Creates a new compilation without any syntax trees. Preserves metadata info
-        /// from this compilation for use with trees added later. 
+        /// from this compilation for use with trees added later.
         /// </summary>
         public new CSharpCompilation RemoveAllSyntaxTrees()
         {
@@ -805,7 +806,7 @@ internal override bool HasSubmissionResult()
             }
 
             // TODO(tomat): Consider comparing #r's of the old and the new tree. If they are exactly the same we could still reuse.
-            // This could be a perf win when editing a script file in the IDE. The services create a new compilation every keystroke 
+            // This could be a perf win when editing a script file in the IDE. The services create a new compilation every keystroke
             // that replaces the tree with a new one.
             var reuseReferenceManager = !oldTree.HasReferenceOrLoadDirectives() && !newTree.HasReferenceOrLoadDirectives();
             syntaxAndDeclarations = syntaxAndDeclarations.ReplaceSyntaxTree(oldTree, newTree);
@@ -872,7 +873,7 @@ internal IEnumerable<string> ExternAliases
         /// </summary>
         /// <returns><see cref="AssemblySymbol"/> or <see cref="ModuleSymbol"/> corresponding to the given reference or null if there is none.</returns>
         /// <remarks>
-        /// Uses object identity when comparing two references. 
+        /// Uses object identity when comparing two references.
         /// </remarks>
         internal new Symbol GetAssemblyOrModuleSymbol(MetadataReference reference)
         {
@@ -976,7 +977,7 @@ public MetadataReference GetDirectiveReference(ReferenceDirectiveTriviaSyntax di
         /// <summary>
         /// Get all modules in this compilation, including the source module, added modules, and all
         /// modules of referenced assemblies that do not come from an assembly with an extern alias.
-        /// Metadata imported from aliased assemblies is not visible at the source level except through 
+        /// Metadata imported from aliased assemblies is not visible at the source level except through
         /// the use of an extern alias directive. So exclude them from this list which is used to construct
         /// the global namespace.
         /// </summary>
@@ -1017,7 +1018,7 @@ internal void GetUnaliasedReferencedAssemblies(ArrayBuilder<AssemblySymbol> asse
         }
 
         /// <summary>
-        /// Gets the <see cref="MetadataReference"/> that corresponds to the assembly symbol. 
+        /// Gets the <see cref="MetadataReference"/> that corresponds to the assembly symbol.
         /// </summary>
         public new MetadataReference GetMetadataReference(IAssemblySymbol assemblySymbol)
         {
@@ -1065,7 +1066,7 @@ internal SourceAssemblySymbol SourceAssembly
         }
 
         /// <summary>
-        /// Gets the root namespace that contains all namespaces and types defined in source code or in 
+        /// Gets the root namespace that contains all namespaces and types defined in source code or in
         /// referenced metadata, merged into a single namespace hierarchy.
         /// </summary>
         internal new NamespaceSymbol GlobalNamespace
@@ -1075,7 +1076,7 @@ internal SourceAssemblySymbol SourceAssembly
                 if ((object)_lazyGlobalNamespace == null)
                 {
                     // Get the root namespace from each module, and merge them all together
-                    // Get all modules in this compilation, ones referenced directly by the compilation 
+                    // Get all modules in this compilation, ones referenced directly by the compilation
                     // as well as those referenced by all referenced assemblies.
 
                     var modules = ArrayBuilder<ModuleSymbol>.GetInstance();
@@ -1369,7 +1370,7 @@ internal bool DeclaresTheObjectClass
         internal new MethodSymbol GetEntryPoint(CancellationToken cancellationToken)
         {
             EntryPoint entryPoint = GetEntryPointAndDiagnostics(cancellationToken);
-            return entryPoint == null ? null : entryPoint.MethodSymbol;
+            return entryPoint?.MethodSymbol;
         }
 
         internal EntryPoint GetEntryPointAndDiagnostics(CancellationToken cancellationToken)
@@ -1456,9 +1457,9 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
                 var viableEntryPoints = ArrayBuilder<MethodSymbol>.GetInstance();
                 foreach (var candidate in entryPointCandidates)
                 {
-                    if (!candidate.HasEntryPointSignature())
+                    if (!candidate.HasEntryPointSignature(this))
                     {
-                        // a single error for partial methods:
+                        // a single error for partial methods
                         warnings.Add(ErrorCode.WRN_InvalidMainSig, candidate.Locations.First(), candidate);
                         continue;
                     }
@@ -1472,7 +1473,8 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
 
                     if (candidate.IsAsync)
                     {
-                        diagnostics.Add(ErrorCode.ERR_MainCantBeAsync, candidate.Locations.First(), candidate);
+                        // PROTOTYPE(async-main): Get the diagnostic to point to a smaller syntax piece.
+                        CheckFeatureAvailability(candidate.DeclaringSyntaxReferences.Single().GetSyntax(), MessageID.IDS_FeatureAsyncMain, diagnostics);
                     }
 
                     viableEntryPoints.Add(candidate);
@@ -2171,8 +2173,8 @@ internal ImmutableArray<Diagnostic> GetDiagnosticsForSyntaxTree(
             {
                 //remove some errors that don't have locations in the tree, like "no suitable main method."
                 //Members in trees other than the one being examined are not compiled. This includes field
-                //initializers which can result in 'field is never initialized' warnings for fields in partial 
-                //types when the field is in a different source file than the one for which we're getting diagnostics. 
+                //initializers which can result in 'field is never initialized' warnings for fields in partial
+                //types when the field is in a different source file than the one for which we're getting diagnostics.
                 //For that reason the bag must be also filtered by tree.
                 IEnumerable<Diagnostic> methodBodyDiagnostics = GetDiagnosticsForMethodBodiesInTree(syntaxTree, filterSpanWithinTree, cancellationToken);
 
@@ -2730,14 +2732,14 @@ protected override INamedTypeSymbol CommonCreateTupleTypeSymbol(
             return TupleTypeSymbol.Create(
                 locationOpt: null, // no location for the type declaration
                 elementTypes: typesBuilder.ToImmutableAndFree(),
-                elementLocations: elementLocations, 
-                elementNames: elementNames, 
+                elementLocations: elementLocations,
+                elementNames: elementNames,
                 compilation: this,
                 shouldCheckConstraints: false);
         }
 
         protected override INamedTypeSymbol CommonCreateTupleTypeSymbol(
-            INamedTypeSymbol underlyingType, 
+            INamedTypeSymbol underlyingType,
             ImmutableArray<string> elementNames,
             ImmutableArray<Location> elementLocations)
         {
@@ -2757,7 +2759,7 @@ protected override INamedTypeSymbol CommonCreateTupleTypeSymbol(
         }
 
         protected override INamedTypeSymbol CommonCreateAnonymousTypeSymbol(
-            ImmutableArray<ITypeSymbol> memberTypes, 
+            ImmutableArray<ITypeSymbol> memberTypes,
             ImmutableArray<string> memberNames,
             ImmutableArray<Location> memberLocations,
             ImmutableArray<bool> memberIsReadOnly)
@@ -2855,7 +2857,7 @@ internal override int CompareSourceLocations(Location loc1, Location loc2)
         #endregion
 
         /// <summary>
-        /// Returns if the compilation has all of the members necessary to emit metadata about 
+        /// Returns if the compilation has all of the members necessary to emit metadata about
         /// dynamic types.
         /// </summary>
         /// <returns></returns>
@@ -2911,7 +2913,7 @@ internal bool EnableEnumArrayBlockInitialization
                 return sustainedLowLatency != null && sustainedLowLatency.ContainingAssembly == Assembly.CorLibrary;
             }
         }
-        
+
         internal override bool IsIOperationFeatureEnabled()
         {
             var options = (CSharpParseOptions)this.SyntaxTrees.FirstOrDefault()?.Options;
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index 5814b2db8a06b..83890349f82bd 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -1104,7 +1104,7 @@ internal enum ErrorCode
         ERR_VarargsAsync = 4006,
         ERR_ByRefTypeAndAwait = 4007,
         ERR_BadAwaitArgVoidCall = 4008,
-        ERR_MainCantBeAsync = 4009,
+        // ERR_MainCantBeAsync = 4009,
         ERR_CantConvAsyncAnonFuncReturns = 4010,
         ERR_BadAwaiterPattern = 4011,
         ERR_BadSpecialByRefLocal = 4012,
diff --git a/src/Compilers/CSharp/Portable/Errors/MessageID.cs b/src/Compilers/CSharp/Portable/Errors/MessageID.cs
index db433a2c5b01e..2f736750f6f49 100644
--- a/src/Compilers/CSharp/Portable/Errors/MessageID.cs
+++ b/src/Compilers/CSharp/Portable/Errors/MessageID.cs
@@ -127,6 +127,7 @@ internal enum MessageID
         IDS_FeatureExpressionBodiedAccessor = MessageBase + 12715,
         IDS_FeatureExpressionBodiedDeOrConstructor = MessageBase + 12716,
         IDS_ThrowExpression = MessageBase + 12717,
+        IDS_FeatureAsyncMain = MessageBase + 12718,
     }
 
     // Message IDs may refer to strings that need to be localized.
@@ -183,6 +184,10 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
             // Checks are in the LanguageParser unless otherwise noted.
             switch (feature)
             {
+                // C# 7.1 features.
+                case MessageID.IDS_FeatureAsyncMain:
+                    return LanguageVersion.CSharp7_1;
+
                 // C# 7 features.
                 case MessageID.IDS_FeatureBinaryLiteral:
                 case MessageID.IDS_FeatureDigitSeparator:
diff --git a/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs
index a308c50a9554c..1a4322b09f4af 100644
--- a/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs
@@ -84,7 +84,7 @@ public virtual bool IsGenericMethod
         internal virtual bool IsDirectlyExcludedFromCodeCoverage { get => false; }
 
         /// <summary>
-        /// Returns true if this method is an extension method. 
+        /// Returns true if this method is an extension method.
         /// </summary>
         public abstract bool IsExtensionMethod { get; }
 
@@ -114,7 +114,7 @@ public virtual bool IsGenericMethod
         internal abstract IEnumerable<Microsoft.Cci.SecurityAttribute> GetSecurityInformation();
 
         /// <summary>
-        /// Marshalling information for return value (FieldMarshal in metadata). 
+        /// Marshalling information for return value (FieldMarshal in metadata).
         /// </summary>
         internal abstract MarshalPseudoCustomAttributeData ReturnValueMarshallingInformation { get; }
 
@@ -133,7 +133,7 @@ public virtual bool IsGenericMethod
         /// <summary>
         /// Returns true if this method hides base methods by name. This cannot be specified directly
         /// in the C# language, but can be true for methods defined in other languages imported from
-        /// metadata. The equivalent of the "hidebyname" flag in metadata. 
+        /// metadata. The equivalent of the "hidebyname" flag in metadata.
         /// </summary>
         public abstract bool HidesBaseMethodsByName { get; }
 
@@ -184,7 +184,7 @@ public virtual bool IsCheckedBuiltin
         public abstract TypeSymbol ReturnType { get; }
 
         /// <summary>
-        /// Returns the type arguments that have been substituted for the type parameters. 
+        /// Returns the type arguments that have been substituted for the type parameters.
         /// If nothing has been substituted for a given type parameter,
         /// then the type parameter itself is consider the type argument.
         /// </summary>
@@ -275,13 +275,13 @@ internal virtual bool IsExplicitInterfaceImplementation
         /// Returns interface methods explicitly implemented by this method.
         /// </summary>
         /// <remarks>
-        /// Methods imported from metadata can explicitly implement more than one method, 
+        /// Methods imported from metadata can explicitly implement more than one method,
         /// that is why return type is ImmutableArray.
         /// </remarks>
         public abstract ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations { get; }
 
         /// <summary>
-        /// Returns the list of custom modifiers, if any, associated with the return type. 
+        /// Returns the list of custom modifiers, if any, associated with the return type.
         /// </summary>
         public abstract ImmutableArray<CustomModifier> ReturnTypeCustomModifiers { get; }
 
@@ -309,7 +309,7 @@ public virtual ImmutableArray<CSharpAttributeData> GetReturnTypeAttributes()
         /// returns the property that this method is the getter or setter for.
         /// If this method has MethodKind of MethodKind.EventAdd or MethodKind.EventRemove,
         /// returns the event that this method is the adder or remover for.
-        /// Note, the set of possible associated symbols might be expanded in the future to 
+        /// Note, the set of possible associated symbols might be expanded in the future to
         /// reflect changes in the languages.
         /// </summary>
         public abstract Symbol AssociatedSymbol { get; }
@@ -327,19 +327,19 @@ internal MethodSymbol GetLeastOverriddenMethod(NamedTypeSymbol accessingTypeOpt)
             while (m.IsOverride && !m.HidesBaseMethodsByName)
             {
                 // We might not be able to access the overridden method. For example,
-                // 
+                //
                 //   .assembly A
                 //   {
                 //      InternalsVisibleTo("B")
                 //      public class A { internal virtual void M() { } }
                 //   }
-                // 
+                //
                 //   .assembly B
                 //   {
                 //      InternalsVisibleTo("C")
                 //      public class B : A { internal override void M() { } }
                 //   }
-                // 
+                //
                 //   .assembly C
                 //   {
                 //      public class C : B { ... new B().M ... }       // A.M is not accessible from here
@@ -374,9 +374,9 @@ internal MethodSymbol GetConstructedLeastOverriddenMethod(NamedTypeSymbol access
         /// <summary>
         /// If this method overrides another method (because it both had the override modifier
         /// and there correctly was a method to override), returns the overridden method.
-        /// Note that if an overriding method D.M overrides C.M, which in turn overrides 
+        /// Note that if an overriding method D.M overrides C.M, which in turn overrides
         /// virtual method A.M, the "overridden method" of D.M is C.M, not the original virtual
-        /// method A.M. Note also that constructed generic methods are not considered to 
+        /// method A.M. Note also that constructed generic methods are not considered to
         /// override anything.
         /// </summary>
         public MethodSymbol OverriddenMethod
@@ -587,7 +587,7 @@ internal bool IsSubmissionInitializer
         }
 
         /// <summary>
-        /// Determines whether this method is a candidate for a default assembly entry point 
+        /// Determines whether this method is a candidate for a default assembly entry point
         /// (i.e. it is a static method called "Main").
         /// </summary>
         internal bool IsEntryPointCandidate
@@ -597,18 +597,56 @@ internal bool IsEntryPointCandidate
 
         /// <summary>
         /// Checks if the method has an entry point compatible signature, i.e.
-        /// - the return type is either void or int
+        /// - the return type is either void, int, <see cref="System.Threading.Tasks.Task" />,
+        /// or <see cref="System.Threading.Tasks.Task{T}" /> where T is an int.
         /// - has either no parameter or a single parameter of type string[]
         /// </summary>
-        internal bool HasEntryPointSignature()
+        internal bool HasEntryPointSignature(CSharpCompilation compilation)
         {
-            if (this.IsVararg)
+
+            bool IsAsyncMainReturnType(TypeSymbol type)
+            {
+                var namedType = type as NamedTypeSymbol;
+                if (namedType == null)
+                {
+                    return false;
+                }
+                else if (namedType.ConstructedFrom == compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_Task))
+                {
+                    // Change this to `namedType.IsNonGenericTaskType` if you want to support "task-like" objects.
+                    return true;
+                }
+                else if (namedType.ConstructedFrom == compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_Task_T))
+                {
+                    // Change this to `namedType.IsGenericTaskType` if you want to support "task-like" objects.
+                    return namedType.TypeArguments[0].SpecialType == SpecialType.System_Int32;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            if (IsVararg)
             {
                 return false;
             }
 
             TypeSymbol returnType = ReturnType;
-            if (returnType.SpecialType != SpecialType.System_Int32 && returnType.SpecialType != SpecialType.System_Void)
+            bool isAsyncMainReturnType = IsAsyncMainReturnType(returnType);
+            if (returnType.SpecialType != SpecialType.System_Int32 && returnType.SpecialType != SpecialType.System_Void && !isAsyncMainReturnType)
+            {
+                return false;
+            }
+
+            // Prior to 7.1, async methods were considered to "have the entrypoint signature".
+            // In order to keep back-compat, we need to let these through if compiling using a previous language version.
+            if (!isAsyncMainReturnType && IsAsync && compilation.LanguageVersion >= LanguageVersion.CSharp7_1)
+            {
+                return false;
+            }
+
+            if (RefKind != RefKind.None)
             {
                 return false;
             }
@@ -733,7 +771,7 @@ public virtual TypeSymbol ReceiverType
         }
 
         /// <summary>
-        /// If this method is a reduced extension method, returns a type inferred during reduction process for the type parameter. 
+        /// If this method is a reduced extension method, returns a type inferred during reduction process for the type parameter.
         /// </summary>
         /// <param name="reducedFromTypeParameter">Type parameter of the corresponding <see cref="ReducedFrom"/> method.</param>
         /// <returns>Inferred type or Nothing if nothing was inferred.</returns>
@@ -883,7 +921,7 @@ internal bool CalculateUseSiteDiagnostic(ref DiagnosticInfo result)
                 return true;
             }
 
-            // If the member is in an assembly with unified references, 
+            // If the member is in an assembly with unified references,
             // we check if its definition depends on a type from a unified reference.
             if (this.ContainingModule.HasUnifiedReferences)
             {
@@ -903,7 +941,7 @@ internal bool CalculateUseSiteDiagnostic(ref DiagnosticInfo result)
         }
 
         /// <summary>
-        /// Return error code that has highest priority while calculating use site error for this symbol. 
+        /// Return error code that has highest priority while calculating use site error for this symbol.
         /// </summary>
         protected override int HighestPriorityUseSiteError
         {
@@ -944,7 +982,7 @@ internal virtual TypeSymbol IteratorElementType
 
         /// <summary>
         /// Generates bound block representing method's body for methods in lowered form and adds it to
-        /// a collection of method bodies of the current module. This method is supposed to only be 
+        /// a collection of method bodies of the current module. This method is supposed to only be
         /// called for method symbols which return SynthesizesLoweredBoundBody == true.
         /// </summary>
         internal virtual void GenerateMethodBody(TypeCompilationState compilationState, DiagnosticBag diagnostics)
@@ -975,7 +1013,7 @@ internal virtual bool SynthesizesLoweredBoundBody
         /// <remarks>
         /// Syntax offset is a unique identifier for the local within the emitted method body.
         /// It's based on position of the local declarator. In single-part method bodies it's simply the distance
-        /// from the start of the method body syntax span. If a method body has multiple parts (such as a constructor 
+        /// from the start of the method body syntax span. If a method body has multiple parts (such as a constructor
         /// comprising of code for member initializers and constructor initializer calls) the offset is calculated
         /// as if all source these parts were concatenated together and prepended to the constructor body.
         /// The resulting syntax offset is then negative for locals defined outside of the constructor body.
@@ -1227,7 +1265,7 @@ public virtual bool IsTupleMethod
 
         /// <summary>
         /// If this is a method of a tuple type, return corresponding underlying method from the
-        /// tuple underlying type. Otherwise, null. 
+        /// tuple underlying type. Otherwise, null.
         /// </summary>
         public virtual MethodSymbol TupleUnderlyingMethod
         {
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EntryPointTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EntryPointTests.cs
index d9f218f2d9ef7..27a16b65d939e 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EntryPointTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EntryPointTests.cs
@@ -1444,5 +1444,45 @@ public static void Main(string[] args) {}
                 Diagnostic(ErrorCode.ERR_MultipleEntryPoints, "Main").WithLocation(4, 24)
                 );
         }
+
+        [WorkItem(17923, "https://github.com/dotnet/roslyn/issues/17923")]
+        [Fact]
+        [CompilerTrait(CompilerFeature.RefLocalsReturns)]
+        public void RefIntReturnMainEmpty()
+        {
+            var source = @"
+class Program
+{
+    public static ref int Main() { throw new System.Exception(); }
+}";
+
+            var compilation = CreateCompilationWithMscorlib(source, options: TestOptions.DebugExe);
+            compilation.VerifyDiagnostics(
+                // (4,27): warning CS0028: 'Program.Main()' has the wrong signature to be an entry point
+                //     public static ref int Main() {}
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main()").WithLocation(4, 27),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [WorkItem(17923, "https://github.com/dotnet/roslyn/issues/17923")]
+        [Fact]
+        [CompilerTrait(CompilerFeature.RefLocalsReturns)]
+        public void RefIntReturnMainWithParams()
+        {
+            var source = @"
+class Program
+{
+    public static ref int Main(string[] args) { throw new System.Exception(); }
+}";
+
+            var compilation = CreateCompilationWithMscorlib(source, options: TestOptions.DebugExe);
+            compilation.VerifyDiagnostics(
+                // (4,27): warning CS0028: 'Program.Main(string[])' has the wrong signature to be an entry point
+                //     public static ref int Main(string[] args) { throw new System.Exception(); }
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main(string[])"),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint));
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs
index 5fd8b1578b9a7..692b282000480 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs
@@ -2,6 +2,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
@@ -88,7 +89,7 @@ public void BadAsyncConstructor()
         {
             var source = @"
 class C {
-    async public C() { } 
+    async public C() { }
 }";
             CreateCompilationWithMscorlib45(source).VerifyDiagnostics(
                 Diagnostic(ErrorCode.ERR_BadMemberFlag, "C").WithArguments("async"));
@@ -215,7 +216,7 @@ public void TaskRetNoObjectRequired()
 class C
 {
     static void InferTask(Func<Task> x) { }
-    
+
     static void InferTaskOrTaskT(Func<Task> x) { }
     static void InferTaskOrTaskT(Func<Task<int>> x) { }
 
@@ -939,7 +940,7 @@ public void BadAwaitInCatchFilter()
 
 class Test
 {
-    async static Task M1() 
+    async static Task M1()
     {
         try
         {
@@ -1067,7 +1068,7 @@ public static async void F()
         object o = new object();
         lock(await Task.Factory.StartNew(() => o))
         {
-            
+
         }
     }
 
@@ -1188,7 +1189,7 @@ public void AsyncExplicitInterfaceImplementation()
 
 interface IInterface
 {
-    void F(); 
+    void F();
 }
 
 class C : IInterface
@@ -1200,7 +1201,7 @@ async void IInterface.F()
 
     static void Main()
     {
-        
+
     }
 }";
             CreateCompilationWithMscorlib45(source).VerifyDiagnostics();
@@ -1212,16 +1213,109 @@ public void AsyncInterfaceMember()
             var source = @"
 interface IInterface
 {
-    async void F(); 
+    async void F();
 }";
             CreateCompilationWithMscorlib45(source).VerifyDiagnostics(
                 // (4,16): error CS0106: The modifier 'async' is not valid for this item
-                //     async void F(); 
+                //     async void F();
                 Diagnostic(ErrorCode.ERR_BadMemberFlag, "F").WithArguments("async"));
         }
 
         [Fact]
-        public void MainCantBeAsync()
+        public void MainCanBeAsyncWithArgs()
+        {
+            var origSource = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task Main(string[] args)
+    {
+        await Task.Factory.StartNew(() => { });
+    }
+}";
+            var sources = new string[] { origSource, origSource.Replace("async ", "").Replace("await", "return") };
+            foreach (var source in sources)
+            {
+                var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+                compilation.VerifyDiagnostics();
+                var entry = compilation.GetEntryPoint(CancellationToken.None);
+                Assert.NotNull(entry);
+                Assert.Equal("System.Threading.Tasks.Task A.Main(System.String[] args)", entry.ToTestDisplayString());
+            }
+        }
+
+        [Fact]
+        public void MainCantBeAsyncWithRefTask()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static ref Task Main(string[] args)
+    {
+        throw new System.Exception();
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics(
+                // (6,21): warning CS0028: 'A.Main(string[])' has the wrong signature to be an entry point
+                //     static ref Task Main(string[] args)
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main(string[])").WithLocation(6, 21),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void MainCantBeAsyncWithArgs_CSharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task Main(string[] args)
+    {
+        await Task.Factory.StartNew(() => { });
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            compilation.VerifyDiagnostics(
+                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     async static Task Main(string[] args)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task Main(string[] args)
+    {
+        await Task.Factory.StartNew(() => { });
+    }").WithArguments("async main", "7.1").WithLocation(6, 5));
+        }
+
+        [Fact]
+        public void MainCanBeAsync()
+        {
+            var origSource = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task Main()
+    {
+        await Task.Factory.StartNew(() => { });
+    }
+}";
+            var sources = new string[] { origSource, origSource.Replace("async ", "").Replace("await", "return") };
+            foreach (var source in sources)
+            {
+                var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+                compilation.VerifyDiagnostics();
+                var entry = compilation.GetEntryPoint(CancellationToken.None);
+                Assert.NotNull(entry);
+                Assert.Equal("System.Threading.Tasks.Task A.Main()", entry.ToTestDisplayString());
+            }
+        }
+
+        [Fact]
+        public void MainCantBeAsyncVoid()
         {
             var source = @"
 using System.Threading.Tasks;
@@ -1233,10 +1327,211 @@ async static void Main()
         await Task.Factory.StartNew(() => { });
     }
 }";
-            CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe).VerifyDiagnostics(
-                // (4,23): error CS4009: 'A.Main()': an entry point cannot be marked with the 'async' modifier
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics(
+                // (6,23): warning CS0028: 'A.Main()' has the wrong signature to be an entry point
+                //     async static void Main()
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main()").WithLocation(6, 23),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+            var entry = compilation.GetEntryPoint(CancellationToken.None);
+            Assert.Null(entry);
+        }
+
+        [Fact]
+        public void MainCantBeAsyncVoid_CSharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static void Main()
+    {
+        await Task.Factory.StartNew(() => { });
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            compilation.VerifyDiagnostics(
+                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     async static void Main()
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static void Main()
+    {
+        await Task.Factory.StartNew(() => { });
+    }").WithArguments("async main", "7.1").WithLocation(6, 5));
+        }
+
+        [Fact]
+        public void MainCantBeAsyncInt()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static int Main()
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics(
+                // (6,22): error CS1983: The return type of an async method must be void, Task or Task<T>
+                //     async static int Main()
+                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "Main").WithLocation(6, 22),
+                // (6,23): warning CS0028: 'A.Main()' has the wrong signature to be an entry point
                 //     async static void Main()
-                Diagnostic(ErrorCode.ERR_MainCantBeAsync, "Main").WithArguments("A.Main()"));
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main()").WithLocation(6, 22),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+            var entry = compilation.GetEntryPoint(CancellationToken.None);
+            Assert.Null(entry);
+        }
+
+        [Fact]
+        public void MainCantBeAsyncInt_CSharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static int Main()
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            compilation.VerifyDiagnostics(
+                // (6,22): error CS1983: The return type of an async method must be void, Task or Task<T>
+                //     async static int Main()
+                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "Main"),
+                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     async static int Main()
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static int Main()
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }").WithArguments("async main", "7.1").WithLocation(6, 5)
+);
+        }
+
+        [Fact]
+        public void MainCanBeAsyncAndGenericOnIntWithArgs()
+        {
+            var origSource = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task<int> Main(string[] args)
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }
+}";
+            var sources = new string[] { origSource, origSource.Replace("async ", "").Replace("await", "") };
+            foreach (var source in sources)
+            {
+                var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+                compilation.VerifyDiagnostics();
+                var entry = compilation.GetEntryPoint(CancellationToken.None);
+                Assert.NotNull(entry);
+                Assert.Equal("System.Threading.Tasks.Task<System.Int32> A.Main(System.String[] args)", entry.ToTestDisplayString());
+            }
+        }
+
+        [Fact]
+        public void MainCantBeAsyncAndGenericOnIntWithArgs_Csharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task<int> Main(string[] args)
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }
+}";
+                var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+                compilation.VerifyDiagnostics(
+// (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     async static Task<int> Main(string[] args)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task<int> Main(string[] args)
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }").WithArguments("async main", "7.1").WithLocation(6, 5)
+);
+        }
+
+        [Fact]
+        public void MainCanBeAsyncAndGenericOnInt()
+        {
+            var origSource = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task<int> Main()
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }
+}";
+            var sources = new string[] { origSource, origSource.Replace("async ", "").Replace("await", "") };
+            foreach (var source in sources)
+            {
+                var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+                compilation.VerifyDiagnostics();
+                var entry = compilation.GetEntryPoint(CancellationToken.None);
+                Assert.NotNull(entry);
+                Assert.Equal("System.Threading.Tasks.Task<System.Int32> A.Main()", entry.ToTestDisplayString());
+            }
+        }
+
+        [Fact]
+        public void MainCantBeAsyncAndGenericOnInt_CSharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task<int> Main()
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }
+}";
+                var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+                compilation.VerifyDiagnostics(
+                    // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                    //     async static Task<int> Main()
+                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task<int> Main()
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }").WithArguments("async main", "7.1").WithLocation(6, 5)
+                    );
+        }
+
+        [Fact]
+        public void MainCantBeAsyncAndGenericOverFloats()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task<float> Main()
+    {
+        await Task.Factory.StartNew(() => { });
+        return 0;
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics(
+                // (6,30): warning CS0028: 'A.Main()' has the wrong signature to be an entry point
+                //     async static Task<float> Main()
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main()").WithLocation(6, 30),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1) );
         }
 
         [Fact]
@@ -1252,10 +1547,10 @@ async static void Main<T>()
         await Task.Factory.StartNew(() => { });
     }
 }";
-            CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe).VerifyDiagnostics(
+            CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1)).VerifyDiagnostics(
                 // (4,23): warning CS0402: 'A.Main<T>()': an entry point cannot be generic or in a generic type
                 //     async static void Main<T>()
-                Diagnostic(ErrorCode.WRN_MainCantBeGeneric, "Main").WithArguments("A.Main<T>()"),
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main<T>()"),
                 // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
                 Diagnostic(ErrorCode.ERR_NoEntryPoint));
         }
@@ -1829,7 +2124,7 @@ static Task<T> Foo<T>(T t)
     {
         return Task.Run(async () => { return t; });
     }
-    
+
     static int Main()
     {
         return 0;
@@ -1865,7 +2160,7 @@ class Test
     static async Task<dynamic> Meth1()
     {
         throw new EntryPointNotFoundException();
-        Foo();       
+        Foo();
         return """";
     }
 
@@ -1891,10 +2186,10 @@ static int Main()
                 //     static async Task<dynamic> Meth1()
                 Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "Meth1"),
                 // (23,9): warning CS4014: Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'await' operator to the result of the call.
-                //         Foo();       
+                //         Foo();
                 Diagnostic(ErrorCode.WRN_UnobservedAwaitableExpression, "Foo()"),
                 // (23,9): warning CS0162: Unreachable code detected
-                //         Foo();       
+                //         Foo();
                 Diagnostic(ErrorCode.WRN_UnreachableCode, "Foo"),
                 // (27,33): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
                 //     static async Task<decimal?> Meth2()
@@ -2908,7 +3203,7 @@ public void Meth()
                                 Foo();
                             });
                     };
-            });      
+            });
     }
 
     static int Main()
@@ -2950,7 +3245,7 @@ public void Meth()
                     return """";
                 };
             del3();
-            
+
         };
     }
 
@@ -2981,7 +3276,7 @@ public static Task<int> ExMeth(this int i)
         return (Task<int>) Foo();
     }
 }
-class Test 
+class Test
 {
     public static int amount=0;
     static int Main()
@@ -3066,7 +3361,7 @@ public Task Foo2()
         return Task.Run(() => { });
     }
 }
-class Test 
+class Test
 {
     static int Main()
     {
@@ -3097,7 +3392,7 @@ public async Task Foo()
     {
         await Task.Delay(10);
     }
-    public void Dispose() 
+    public void Dispose()
     {
         Foo();
     }
@@ -3486,19 +3781,39 @@ public static int Main()
         public void Repro_17885()
         {
             var source = @"
+using System.Threading.Tasks;
 class Test
 {
-    async public static void Main()
+    async public static Task Main()
     {
     }
 }";
-            CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe).VerifyDiagnostics(
-                // (4,30): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
-                //     async public static void Main()
+            CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1)).VerifyDiagnostics(
+                // (5,30): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
+                //     async public static Task Main()
+                Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "Main"));
+        }
+
+        [Fact, WorkItem(547081, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/547081")]
+        public void Repro_17885_CSharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+class Test
+{
+    async public static Task Main()
+    {
+    }
+}";
+            CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7)).VerifyDiagnostics(
+                // (5,30): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
+                //     async public static Task Main()
                 Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "Main"),
-                // (4,30): error CS4009: 'Test.Main()': an entry point cannot be marked with the 'async' modifier
-                //     async public static void Main()
-                Diagnostic(ErrorCode.ERR_MainCantBeAsync, "Main").WithArguments("Test.Main()"));
+                // (5,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     async public static Task Main()
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async public static Task Main()
+    {
+    }").WithArguments("async main", "7.1").WithLocation(5, 5));
         }
 
         [Fact, WorkItem(547088, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/547088")]
@@ -3511,7 +3826,7 @@ static int Main()
     {
         return 1;
     }
- 
+
     public async void Foo(ref int x)
     { }
 }";
@@ -3582,7 +3897,7 @@ public void GetAwaiterIsExtension()
             var source =
 @"using System;
 using A;
- 
+
 namespace A
 {
     public class IAS<T>
@@ -3717,7 +4032,7 @@ public void ReturnExpressionNotConvertible()
         {
             string source = @"
 using System.Threading.Tasks;
- 
+
 class Program
 {
     static async Task<T> Foo<T>()
@@ -3740,9 +4055,9 @@ public void RefParameterOnAsyncLambda()
             string source = @"
 using System;
 using System.Threading.Tasks;
- 
+
 delegate Task D(ref int x);
- 
+
 class C
 {
     static void Main()
@@ -3752,7 +4067,7 @@ static void Main()
             await Task.Delay(500);
             Console.WriteLine(i++);
         };
- 
+
         int x = 5;
         d(ref x).Wait();
         Console.WriteLine(x);
@@ -3830,7 +4145,7 @@ public void DelegateTypeWithNoInvokeMethod()
 @".class public auto ansi sealed D`1<T>
        extends [mscorlib]System.MulticastDelegate
 {
-  .method public hidebysig specialname rtspecialname 
+  .method public hidebysig specialname rtspecialname
           instance void  .ctor(object 'object',
                                native int 'method') runtime managed
   {

From c371dc16270dec9e94fec20079eae2740a1344a2 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Fri, 7 Apr 2017 13:21:16 -0700
Subject: [PATCH 010/284] Document refout feature (#18501)

---
 docs/features/refout.md | 78 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 docs/features/refout.md

diff --git a/docs/features/refout.md b/docs/features/refout.md
new file mode 100644
index 0000000000000..9e533c52c72f7
--- /dev/null
+++ b/docs/features/refout.md
@@ -0,0 +1,78 @@
+# Reference assemblies
+
+Reference assemblies are metadata-only assemblies with the minimum amount of metadata to preserve the compile-time behavior of consumers (diagnostics may be affected, though).
+
+## Scenarios
+There are 4 scenarios:
+
+1. The traditional one, where an assembly is emitted as the primary output (`/out` command-line parameter, or `peStream` parameter in `Compilation.Emit` APIs).
+2. The IDE scenario, where the metadata-only assembly is emitted (via `Emit` API), still as the primary output. Later on, the IDE is interested to get metadata-only assemblies even when there are errors in the compilation.
+3. The CoreFX scenario, where only the ref assembly is emitted, still as the primary output (`/refonly` command-line parameter) 
+4. The MSBuild scenario, which is the new scenario, where both a real assembly is emitted as the primary output, and a ref assembly is emitted as the secondary output (`/refout` command-line parameter, or `metadataPeStream` parameter in `Emit`).
+
+
+## Definition of ref assemblies
+Metadata-only assembly have their method bodies replaced with a single `throw null` body, but include all members except anonymous types. The reason for using `throw null` bodies (as opposed to no bodies) is so that PEVerify could run and pass (thus validating the completeness of the metadata).
+Ref assemblies further remove metadata (private members) from metadata-only assemblies.
+
+A reference assembly will only have references for what it needs in the API surface. The real assembly may have additional references related to specific implementations. For instance, the reference assembly for `class C { private void M() { dynamic .... } }` will not have any references for `dynamic` types.
+
+Private function-members (methods, properties and events) will be removed. If there are no `InternalsVisibleTo` attributes, do the same for internal function-members
+
+All types (including private or nested types) must be kept in reference assemblies.
+
+All fields of a struct will be kept (in C# 7.1 timeframe), but this can later be refined. There are three cases to consider (ref case, struct case, generic case), where we could possibly substitute the fields with adequate placeholders that would minimize the rate of change of the ref assembly.
+
+Reference assemblies will include an assembly-level `ReferenceAssembly` attribute. If such an attribute is found in source, we won't need to synthesize it. Because of this attribute, runtimes will refuse to load reference assemblies.
+
+## API changes
+
+### Command-line
+Two mutually exclusive command-line parameters will be added to `csc.exe` and `vbc.exe`:
+- `/refout`
+- `/refonly`
+
+The `/refout` parameter specifies a file path where the ref assembly should be output. This translates to `metadataPeStream` in the `Emit` API (see details below).
+
+The `/refonly` parameter is a flag that indicates that a ref assembly should be output instead of an implementation assembly. 
+The `/refonly` parameter is not allowed together with the `/refout` parameter, as it doesn't make sense to have both the primary and secondary outputs be ref assemblies. Also, the `/refonly` parameter silently disables outputting PDBs, as ref assemblies cannot be executed. 
+The `/refonly` parameter translates to `EmitMetadataOnly` being `true`, and `IncludePrivateMembers` being `false` in the `Emit` API (see details below).
+
+When the compiler produces documentation, the contents produced will match the APIs that go into the primary output. In other words, the documentation will be filtered down when using the `/refonly` parameter.
+
+The compilation from the command-line will either produce both assemblies (implementation and ref) or neither. There is no "partial success" scenario.
+
+### CscTask/CoreCompile
+The `CoreCompile` target will support a new output, called `IntermediateRefAssembly`, which parallels the existing `IntermediateAssembly`.
+The `Csc` task will support a new output, called `OutputRefAssembly`, which parallels the existing `OutputAssembly`.
+Both of those basically map to the `/refout` command-line parameter.
+
+An additional task, called `CopyRefAssembly`, will be provided along with the existing `Csc` task. It takes a `SourcePath` and a `DestinationPath` and generally copies the file from the source over to the destination. But if it can determine that the contents of those two files match, then the destination file is left untouched.
+
+### CodeAnalysis APIs
+It is already possible to produce metadata-only assemblies by using `EmitOptions.EmitMetadataOnly`, which is used in IDE scenarios with cross-language dependencies.
+The compiler will be updated to honour the `EmitOptions.IncludePrivateMembers` flag as well. When combined with `EmitMetadataOnly` or a `metadataPeStream` in `Emit`, a ref assembly will be produced.
+The diagnostic check for emitting methods lacking a body (`void M();`) will be moved from declaration diagnostics to regular diagnostics, so that code will successfully emit with `EmitMetadataOnly`.
+Later on, the `EmitOptions.TolerateErrors` flag will allow emitting error types as well.
+
+Going back to the 4 driving scenarios:
+1. For a regular compilation, `EmitMetadataOnly` is left to `false` and no `metadataPeStream` is passed into `Emit`.
+2. For the IDE scenario, `EmitMetadataOnly` is set to `true`, but `IncludePrivateMembers` is left to `true`.
+3. For the CoreFX scenario, ref assembly source code is used as input, `EmitMetadataOnly` is set to `true`, and `IncludePrivateMembers` is set to `false`.
+4. For the MSBuild scenario, `EmitMetadataOnly` is left to `false`, a `metadataPeStream` is passed in and `IncludePrivateMembers` is set to `false`.
+
+## Future
+As mentioned above, there may be further refinements after C# 7.1:
+- controlling internals (producing public ref assemblies)
+- produce ref assemblies even when there are errors outside method bodies (emitting error types when `EmitOptions.TolerateErrors` is set)
+
+## Open questions
+- should explicit method implementations be included in ref assemblies?
+- Non-public attributes on public APIs (emit attribute based on accessibility rule)
+- ref assemblies and NoPia
+- `/refout` and `/addmodule`, should we disallow this combination?
+
+## Related issues
+- Produce ref assemblies from command-line and msbuild (https://github.com/dotnet/roslyn/issues/2184)
+- Refine what is in reference assemblies and what diagnostics prevent generating one (https://github.com/dotnet/roslyn/issues/17612)
+- [Are private members part of the API surface?](http://blog.paranoidcoding.com/2016/02/15/are-private-members-api-surface.html)

From 8e6cfc0fbe71934a4e9a626ba88880bc93085bdc Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Fri, 7 Apr 2017 23:57:33 -0700
Subject: [PATCH 011/284] Strip out private members from ref assemblies
 (#18339)

---
 .../CSharp/Portable/CSharpCodeAnalysis.csproj |   1 +
 .../CommandLine/CSharpCommandLineParser.cs    |  13 +-
 .../Portable/Compilation/CSharpCompilation.cs |  17 +-
 .../Portable/Compiler/MethodCompiler.cs       |  35 +-
 .../Emitter/EditAndContinue/EmitHelpers.cs    |   5 +-
 .../EditAndContinue/PEDeltaAssemblyBuilder.cs |   4 +-
 .../Emitter/Model/MethodSymbolAdapter.cs      |   4 +-
 .../Emitter/Model/NamedTypeSymbolAdapter.cs   |  45 +-
 .../Portable/Emitter/Model/PEModuleBuilder.cs |   9 +-
 .../Model/SourceAssemblySymbolAdapter.cs      |  30 ++
 .../Portable/Emitter/Model/SymbolAdapter.cs   |   1 +
 .../Emitter/NoPia/EmbeddedTypesManager.cs     |   2 +-
 .../Symbols/Source/SourceAssemblySymbol.cs    |  18 +-
 .../Test/CommandLine/CommandLineTests.cs      |  61 +--
 .../Attributes/AttributeTests_Assembly.cs     |   6 +-
 .../Attributes/WellKnownAttributesTestBase.cs |   2 +-
 .../CSharp/Test/Emit/CodeGen/CodeGenTests.cs  |   1 +
 .../Test/Emit/CodeGen/CodeGenTupleTest.cs     |   8 +-
 .../Test/Emit/Emit/CompilationEmitTests.cs    | 413 ++++++++++++++++--
 .../EditAndContinue/SymbolMatcherTests.cs     |   4 +-
 .../CSharp/Test/Emit/Emit/EmitMetadata.cs     |   2 +-
 .../Symbol/Symbols/ExtensionMethodTests.cs    |   2 +-
 .../Symbol/Symbols/Source/BaseClassTests.cs   |   2 +-
 .../Test/Symbol/Symbols/Source/MethodTests.cs |  12 +-
 .../Symbol/Symbols/Source/PropertyTests.cs    |   4 +-
 .../CodeAnalysisTest/Emit/EmitOptionsTests.cs |   2 +-
 .../Core/MSBuildTask/CopyRefAssembly.cs       |   6 +-
 .../CodeAnalysisResources.Designer.cs         |   9 +
 .../Core/Portable/CodeAnalysisResources.resx  |   3 +
 .../CodeGen/PrivateImplementationDetails.cs   |   2 +-
 .../Portable/CommandLine/CommonCompiler.cs    |   6 +
 .../Core/Portable/Compilation/Compilation.cs  | 102 +++--
 .../Portable/Emit/CommonPEModuleBuilder.cs    |  14 +-
 src/Compilers/Core/Portable/Emit/Context.cs   |  28 +-
 .../EditAndContinue/DeltaMetadataWriter.cs    |  11 +-
 .../Emit/EditAndContinue/SymbolChanges.cs     |   2 +-
 .../Core/Portable/Emit/EmitOptions.cs         |   8 +-
 .../Portable/Emit/NoPia/CommonEmbeddedType.cs |  29 +-
 .../Emit/NoPia/EmbeddedTypesManager.cs        |   2 +-
 .../Portable/PEWriter/FullMetadataWriter.cs   |  16 +-
 .../Core/Portable/PEWriter/Members.cs         |  22 +
 .../Core/Portable/PEWriter/MetadataWriter.cs  |  29 +-
 .../PEWriter/NoPiaReferenceIndexer.cs         |   2 +-
 .../Core/Portable/PEWriter/PeWriter.cs        |   4 +-
 .../Portable/PEWriter/ReferenceIndexer.cs     |   2 +-
 .../Portable/PEWriter/ReferenceIndexerBase.cs |   2 +-
 .../Core/Portable/PEWriter/RootModuleType.cs  |   4 +-
 src/Compilers/Core/Portable/PEWriter/Types.cs |   2 +-
 .../Core/Portable/PublicAPI.Unshipped.txt     |   2 +-
 .../Attributes/AttributeDescription.cs        |   3 +
 .../CommonAssemblyWellKnownAttributeData.cs   |  18 +
 .../Symbols/ISourceAssemblySymbolInternal.cs  |   2 +
 .../Core/Portable/WellKnownMember.cs          |   1 +
 .../Core/Portable/WellKnownMembers.cs         |   9 +
 src/Compilers/Core/Portable/WellKnownTypes.cs |   5 +-
 .../Portable/BasicCodeAnalysis.vbproj         |   1 +
 .../Portable/CodeGen/EmitStatement.vb         |   2 +-
 .../VisualBasicCommandLineParser.vb           |  13 +-
 .../Portable/Compilation/MethodCompiler.vb    |  21 +-
 .../Compilation/VisualBasicCompilation.vb     |  10 +-
 .../Emit/EditAndContinue/EmitHelpers.vb       |   5 +-
 .../EditAndContinue/PEDeltaAssemblyBuilder.vb |   4 +-
 .../Portable/Emit/NamedTypeSymbolAdapter.vb   |  49 ++-
 .../Emit/NoPia/EmbeddedTypesManager.vb        |   2 +-
 .../Portable/Emit/PEModuleBuilder.vb          |  12 +-
 .../Emit/SourceAssemblySymbolAdapter.vb       |  24 +
 .../Portable/Emit/SymbolAdapter.vb            |   2 +
 .../VisualBasic/Portable/Errors/Errors.vb     |   1 -
 .../Symbols/Source/SourceAssemblySymbol.vb    |  31 +-
 .../Test/CommandLine/CommandLineTests.vb      |  48 +-
 .../Emit/Attributes/AssemblyAttributes.vb     |  10 +-
 .../Test/Emit/Emit/CompilationEmitTests.vb    | 408 +++++++++++++++--
 .../EditAndContinue/SymbolMatcherTests.vb     |   6 +-
 .../SymbolsTests/Source/PropertyTests.vb      |   2 +-
 .../ExpressionCompiler/EvaluationContext.cs   |  12 +-
 .../ReferencedModulesTests.cs                 |   8 +-
 .../Test/ExpressionCompiler/TupleTests.cs     |   6 +-
 .../ExpressionCompilerTestHelpers.cs          |   7 +-
 .../NamespaceTypeDefinitionNoBase.cs          |   2 +-
 .../ExpressionCompiler/EvaluationContext.vb   |   9 +-
 .../ReferencedModulesTests.vb                 |   6 +-
 .../Test/ExpressionCompiler/TupleTests.vb     |   6 +-
 .../Portable/Metadata/MetadataReaderUtils.cs  |  48 +-
 83 files changed, 1404 insertions(+), 399 deletions(-)
 create mode 100644 src/Compilers/CSharp/Portable/Emitter/Model/SourceAssemblySymbolAdapter.cs
 create mode 100644 src/Compilers/VisualBasic/Portable/Emit/SourceAssemblySymbolAdapter.vb

diff --git a/src/Compilers/CSharp/Portable/CSharpCodeAnalysis.csproj b/src/Compilers/CSharp/Portable/CSharpCodeAnalysis.csproj
index 059d2f1220c84..bf32c7f307545 100644
--- a/src/Compilers/CSharp/Portable/CSharpCodeAnalysis.csproj
+++ b/src/Compilers/CSharp/Portable/CSharpCodeAnalysis.csproj
@@ -271,6 +271,7 @@
     <Compile Include="Emitter\EditAndContinue\EmitHelpers.cs" />
     <Compile Include="Emitter\EditAndContinue\PEDeltaAssemblyBuilder.cs" />
     <Compile Include="Emitter\EditAndContinue\CSharpSymbolMatcher.cs" />
+    <Compile Include="Emitter\Model\SourceAssemblySymbolAdapter.cs" />
     <Compile Include="Emitter\Model\ArrayTypeSymbolAdapter.cs" />
     <Compile Include="Emitter\Model\AssemblyReference.cs" />
     <Compile Include="Emitter\Model\AttributeDataAdapter.cs" />
diff --git a/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs b/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
index 7d19a65d1ac3b..e3846cec32b50 100644
--- a/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
+++ b/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
@@ -68,7 +68,7 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
             ImmutableArray<KeyValuePair<string, string>> pathMap = ImmutableArray<KeyValuePair<string, string>>.Empty;
             string outputFileName = null;
             string outputRefFilePath = null;
-            bool metadataOnly = false;
+            bool refOnly = false;
             string documentationPath = null;
             string errorLogPath = null;
             bool parseDocumentationComments = false; //Don't just null check documentationFileName because we want to do this even if the file name is invalid.
@@ -411,7 +411,7 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
                             if (value != null)
                                 break;
 
-                            metadataOnly = true;
+                            refOnly = true;
                             continue;
 
                         case "t":
@@ -1170,12 +1170,12 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
                 diagnosticOptions[o.Key] = o.Value;
             }
 
-            if (metadataOnly && outputRefFilePath != null)
+            if (refOnly && outputRefFilePath != null)
             {
                 AddDiagnostic(diagnostics, diagnosticOptions, ErrorCode.ERR_NoRefOutWhenRefOnly);
             }
 
-            if (outputKind == OutputKind.NetModule && (metadataOnly || outputRefFilePath != null))
+            if (outputKind == OutputKind.NetModule && (refOnly || outputRefFilePath != null))
             {
                 AddDiagnostic(diagnostics, diagnosticOptions, ErrorCode.ERR_NoNetModuleOutputWhenRefOutOrRefOnly);
             }
@@ -1294,7 +1294,8 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
 
             var emitOptions = new EmitOptions
             (
-                metadataOnly: metadataOnly,
+                metadataOnly: refOnly,
+                includePrivateMembers: !refOnly && outputRefFilePath == null,
                 debugInformationFormat: debugInformationFormat,
                 pdbFilePath: null, // to be determined later
                 outputNameOverride: null, // to be determined later
@@ -1322,7 +1323,7 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
                 OutputFileName = outputFileName,
                 OutputRefFilePath = outputRefFilePath,
                 PdbPath = pdbPath,
-                EmitPdb = emitPdb && !metadataOnly, // silently ignore emitPdb when metadataOnly is set
+                EmitPdb = emitPdb && !refOnly, // silently ignore emitPdb when refOnly is set
                 SourceLink = sourceLink,
                 OutputDirectory = outputDirectory,
                 DocumentationPath = documentationPath,
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index 816d82bef8169..fe5d5899819ad 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
@@ -2017,7 +2017,8 @@ private void GetDiagnosticsForAllMethodBodies(DiagnosticBag diagnostics, Cancell
             MethodCompiler.CompileMethodBodies(
                 compilation: this,
                 moduleBeingBuiltOpt: null,
-                generateDebugInfo: false,
+                emittingPdb: false,
+                emitTestCoverageData: false,
                 hasDeclarationErrors: false,
                 diagnostics: diagnostics,
                 filterOpt: null,
@@ -2059,7 +2060,8 @@ private ImmutableArray<Diagnostic> GetDiagnosticsForMethodBodiesInTree(SyntaxTre
             MethodCompiler.CompileMethodBodies(
                 compilation: this,
                 moduleBeingBuiltOpt: null,
-                generateDebugInfo: false,
+                emittingPdb: false,
+                emitTestCoverageData: false,
                 hasDeclarationErrors: false,
                 diagnostics: diagnostics,
                 filterOpt: s => IsDefinedOrImplementedInSourceTree(s, tree, span),
@@ -2301,6 +2303,8 @@ internal override CommonPEModuleBuilder CreateModuleBuilder(
         internal override bool CompileMethods(
             CommonPEModuleBuilder moduleBuilder,
             bool emittingPdb,
+            bool emitMetadataOnly,
+            bool emitTestCoverageData,
             DiagnosticBag diagnostics,
             Predicate<ISymbol> filterOpt,
             CancellationToken cancellationToken)
@@ -2313,9 +2317,8 @@ internal override bool CompileMethods(
             // EmbeddedSymbolManager.MarkAllDeferredSymbolsAsReferenced(this)
 
             var moduleBeingBuilt = (PEModuleBuilder)moduleBuilder;
-            var emitOptions = moduleBeingBuilt.EmitOptions;
 
-            if (emitOptions.EmitMetadataOnly)
+            if (emitMetadataOnly)
             {
                 if (hasDeclarationErrors)
                 {
@@ -2333,7 +2336,7 @@ internal override bool CompileMethods(
             }
             else
             {
-                if ((emittingPdb || emitOptions.EmitTestCoverageData) &&
+                if ((emittingPdb || emitTestCoverageData) &&
                     !CreateDebugDocuments(moduleBeingBuilt.DebugDocumentsBuilder, moduleBeingBuilt.EmbeddedTexts, diagnostics))
                 {
                     return false;
@@ -2349,6 +2352,7 @@ internal override bool CompileMethods(
                     this,
                     moduleBeingBuilt,
                     emittingPdb,
+                    emitTestCoverageData,
                     hasDeclarationErrors,
                     diagnostics: methodBodyDiagnosticBag,
                     filterOpt: filterOpt,
@@ -2369,6 +2373,7 @@ internal override bool GenerateResourcesAndDocumentationComments(
             CommonPEModuleBuilder moduleBuilder,
             Stream xmlDocStream,
             Stream win32Resources,
+            string outputNameOverride,
             DiagnosticBag diagnostics,
             CancellationToken cancellationToken)
         {
@@ -2393,7 +2398,7 @@ internal override bool GenerateResourcesAndDocumentationComments(
             // Use a temporary bag so we don't have to refilter pre-existing diagnostics.
             var xmlDiagnostics = DiagnosticBag.GetInstance();
 
-            string assemblyName = FileNameUtilities.ChangeExtension(moduleBuilder.EmitOptions.OutputNameOverride, extension: null);
+            string assemblyName = FileNameUtilities.ChangeExtension(outputNameOverride, extension: null);
             DocumentationCommentCompiler.WriteDocumentationCommentXml(this, assemblyName, xmlDocStream, xmlDiagnostics, cancellationToken);
 
             return FilterAndAppendAndFreeDiagnostics(diagnostics, ref xmlDiagnostics);
diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
index 8daff0363d5a4..af6f3d6f99fcc 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
@@ -23,6 +23,7 @@ internal sealed class MethodCompiler : CSharpSymbolVisitor<TypeCompilationState,
     {
         private readonly CSharpCompilation _compilation;
         private readonly bool _emittingPdb;
+        private readonly bool _emitTestCoverageData;
         private readonly CancellationToken _cancellationToken;
         private readonly DiagnosticBag _diagnostics;
         private readonly bool _hasDeclarationErrors;
@@ -74,7 +75,7 @@ private void SetGlobalErrorIfTrue(bool arg)
         }
 
         // Internal for testing only.
-        internal MethodCompiler(CSharpCompilation compilation, PEModuleBuilder moduleBeingBuiltOpt, bool emittingPdb, bool hasDeclarationErrors,
+        internal MethodCompiler(CSharpCompilation compilation, PEModuleBuilder moduleBeingBuiltOpt, bool emittingPdb, bool emitTestCoverageData, bool hasDeclarationErrors,
             DiagnosticBag diagnostics, Predicate<Symbol> filterOpt, CancellationToken cancellationToken)
         {
             Debug.Assert(compilation != null);
@@ -90,16 +91,19 @@ internal MethodCompiler(CSharpCompilation compilation, PEModuleBuilder moduleBei
             _hasDeclarationErrors = hasDeclarationErrors;
             SetGlobalErrorIfTrue(hasDeclarationErrors);
 
-            if (emittingPdb || moduleBeingBuiltOpt?.EmitOptions.EmitTestCoverageData == true)
+            if (emittingPdb || emitTestCoverageData)
             {
                 _debugDocumentProvider = (path, basePath) => moduleBeingBuiltOpt.DebugDocumentsBuilder.GetOrAddDebugDocument(path, basePath, CreateDebugDocumentForFile);
             }
+
+            _emitTestCoverageData = emitTestCoverageData;
         }
 
         public static void CompileMethodBodies(
             CSharpCompilation compilation,
             PEModuleBuilder moduleBeingBuiltOpt,
-            bool generateDebugInfo,
+            bool emittingPdb,
+            bool emitTestCoverageData,
             bool hasDeclarationErrors,
             DiagnosticBag diagnostics,
             Predicate<Symbol> filterOpt,
@@ -122,7 +126,8 @@ public static void CompileMethodBodies(
             MethodCompiler methodCompiler = new MethodCompiler(
                 compilation,
                 moduleBeingBuiltOpt,
-                generateDebugInfo,
+                emittingPdb,
+                emitTestCoverageData,
                 hasDeclarationErrors,
                 diagnostics,
                 filterOpt,
@@ -217,6 +222,7 @@ private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModul
                     debugDocumentProvider: null,
                     importChainOpt: null,
                     emittingPdb: false,
+                    emitTestCoverageData: false,
                     dynamicAnalysisSpans: ImmutableArray<SourceSpan>.Empty);
                 moduleBeingBuilt.SetMethodBody(synthesizedEntryPoint, emittedBody);
             }
@@ -546,7 +552,7 @@ private void CompileSynthesizedMethods(PrivateImplementationDetails privateImplC
             Debug.Assert(_moduleBeingBuiltOpt != null);
 
             var compilationState = new TypeCompilationState(null, _compilation, _moduleBeingBuiltOpt);
-            foreach (MethodSymbol method in privateImplClass.GetMethods(new EmitContext(_moduleBeingBuiltOpt, null, diagnostics)))
+            foreach (MethodSymbol method in privateImplClass.GetMethods(new EmitContext(_moduleBeingBuiltOpt, null, diagnostics, metadataOnly: false, includePrivateMembers: true)))
             {
                 Debug.Assert(method.SynthesizesLoweredBoundBody);
                 method.GenerateMethodBody(compilationState, diagnostics);
@@ -640,8 +646,9 @@ private void CompileSynthesizedMethods(TypeCompilationState compilationState)
                             variableSlotAllocatorOpt,
                             diagnosticsThisMethod,
                             _debugDocumentProvider,
-                                method.GenerateDebugInfo ? importChain : null,
+                            method.GenerateDebugInfo ? importChain : null,
                             emittingPdb: _emittingPdb,
+                            emitTestCoverageData: _emitTestCoverageData,
                             dynamicAnalysisSpans: ImmutableArray<SourceSpan>.Empty);
                     }
                 }
@@ -747,6 +754,7 @@ private void CompileFieldLikeEventAccessor(SourceEventSymbol eventSymbol, bool i
                         debugDocumentProvider: _debugDocumentProvider,
                         importChainOpt: null,
                         emittingPdb: false,
+                        emitTestCoverageData: _emitTestCoverageData,
                         dynamicAnalysisSpans: ImmutableArray<SourceSpan>.Empty);
 
                     _moduleBeingBuiltOpt.SetMethodBody(accessor, emittedBody);
@@ -818,7 +826,6 @@ private void CompileMethod(
             }
 
             ImportChain oldImportChain = compilationState.CurrentImportChain;
-            bool instrumentForDynamicAnalysis = _moduleBeingBuiltOpt?.EmitOptions.EmitTestCoverageData == true;
 
             // In order to avoid generating code for methods with errors, we create a diagnostic bag just for this method.
             DiagnosticBag diagsForCurrentMethod = DiagnosticBag.GetInstance();
@@ -887,9 +894,9 @@ private void CompileMethod(
                         analyzedInitializers = InitializerRewriter.RewriteConstructor(processedInitializers.BoundInitializers, methodSymbol);
                         processedInitializers.HasErrors = processedInitializers.HasErrors || analyzedInitializers.HasAnyErrors;
 
-                        if (body != null && ((methodSymbol.ContainingType.IsStructType() && !methodSymbol.IsImplicitConstructor) || instrumentForDynamicAnalysis))
+                        if (body != null && ((methodSymbol.ContainingType.IsStructType() && !methodSymbol.IsImplicitConstructor) || _emitTestCoverageData))
                         {
-                            if (instrumentForDynamicAnalysis && methodSymbol.IsImplicitConstructor)
+                            if (_emitTestCoverageData && methodSymbol.IsImplicitConstructor)
                             {
                                 // Flow analysis over the initializers is necessary in order to find assignments to fields.
                                 // Bodies of implicit constructors do not get flow analysis later, so the initializers
@@ -1004,7 +1011,7 @@ private void CompileMethod(
                             flowAnalyzedBody,
                             previousSubmissionFields,
                             compilationState,
-                            instrumentForDynamicAnalysis,
+                            _emitTestCoverageData,
                             _debugDocumentProvider,
                             ref dynamicAnalysisSpans,
                             diagsForCurrentMethod,
@@ -1046,7 +1053,7 @@ private void CompileMethod(
                             {
                                 // For dynamic analysis, field initializers are instrumented as part of constructors,
                                 // and so are never instrumented here.
-                                Debug.Assert(!instrumentForDynamicAnalysis);
+                                Debug.Assert(!_emitTestCoverageData);
                                 StateMachineTypeSymbol initializerStateMachineTypeOpt;
 
                                 BoundStatement lowered = LowerBodyOrInitializer(
@@ -1055,7 +1062,7 @@ private void CompileMethod(
                                     analyzedInitializers,
                                     previousSubmissionFields,
                                     compilationState,
-                                    instrumentForDynamicAnalysis,
+                                    _emitTestCoverageData,
                                     _debugDocumentProvider,
                                     ref dynamicAnalysisSpans,
                                     diagsForCurrentMethod,
@@ -1119,6 +1126,7 @@ private void CompileMethod(
                             _debugDocumentProvider,
                             importChain,
                             _emittingPdb,
+                            _emitTestCoverageData,
                             dynamicAnalysisSpans);
 
                         _moduleBeingBuiltOpt.SetMethodBody(methodSymbol.PartialDefinitionPart ?? methodSymbol, emittedBody);
@@ -1275,6 +1283,7 @@ private static MethodBody GenerateMethodBody(
             DebugDocumentProvider debugDocumentProvider,
             ImportChain importChainOpt,
             bool emittingPdb,
+            bool emitTestCoverageData,
             ImmutableArray<SourceSpan> dynamicAnalysisSpans)
         {
             // Note: don't call diagnostics.HasAnyErrors() in release; could be expensive if compilation has many warnings.
@@ -1364,7 +1373,7 @@ private static MethodBody GenerateMethodBody(
                 }
 
                 DynamicAnalysisMethodBodyData dynamicAnalysisDataOpt = null;
-                if (moduleBuilder.EmitOptions.EmitTestCoverageData)
+                if (emitTestCoverageData)
                 {
                     Debug.Assert(debugDocumentProvider != null);
                     dynamicAnalysisDataOpt = new DynamicAnalysisMethodBodyData(dynamicAnalysisSpans);
diff --git a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs
index 72b8f9303c885..00ed2fbed8133 100644
--- a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs
@@ -87,6 +87,7 @@ internal static EmitDifferenceResult EmitDifference(
                     updatedMethods,
                     diagnostics,
                     testData?.SymWriterFactory,
+                    emitOptions.PdbFilePath,
                     cancellationToken);
             }
 
@@ -123,8 +124,8 @@ private static EmitBaseline MapToCompilation(
             // Mapping from previous compilation to the current.
             var anonymousTypeMap = moduleBeingBuilt.GetAnonymousTypeMap();
             var sourceAssembly = ((CSharpCompilation)previousGeneration.Compilation).SourceAssembly;
-            var sourceContext = new EmitContext((PEModuleBuilder)previousGeneration.PEModuleBuilder, null, new DiagnosticBag());
-            var otherContext = new EmitContext(moduleBeingBuilt, null, new DiagnosticBag());
+            var sourceContext = new EmitContext((PEModuleBuilder)previousGeneration.PEModuleBuilder, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
+            var otherContext = new EmitContext(moduleBeingBuilt, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
 
             var matcher = new CSharpSymbolMatcher(
                 anonymousTypeMap,
diff --git a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs
index 50fe809e3f4c8..f304335d41170 100644
--- a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs
@@ -33,7 +33,7 @@ public PEDeltaAssemblyBuilder(
             : base(sourceAssembly, emitOptions, outputKind, serializationProperties, manifestResources, additionalTypes: ImmutableArray<NamedTypeSymbol>.Empty)
         {
             var initialBaseline = previousGeneration.InitialBaseline;
-            var context = new EmitContext(this, null, new DiagnosticBag());
+            var context = new EmitContext(this, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
 
             // Hydrate symbols from initial metadata. Once we do so it is important to reuse these symbols across all generations,
             // in order for the symbol matcher to be able to use reference equality once it maps symbols to initial metadata.
@@ -47,7 +47,7 @@ public PEDeltaAssemblyBuilder(
             if (previousGeneration.Ordinal > 0)
             {
                 var previousAssembly = ((CSharpCompilation)previousGeneration.Compilation).SourceAssembly;
-                var previousContext = new EmitContext((PEModuleBuilder)previousGeneration.PEModuleBuilder, null, new DiagnosticBag());
+                var previousContext = new EmitContext((PEModuleBuilder)previousGeneration.PEModuleBuilder, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
 
                 matchToPrevious = new CSharpSymbolMatcher(
                     previousGeneration.AnonymousTypeMap,
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/MethodSymbolAdapter.cs b/src/Compilers/CSharp/Portable/Emitter/Model/MethodSymbolAdapter.cs
index c776c270e26a2..20bb10723f950 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/MethodSymbolAdapter.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/MethodSymbolAdapter.cs
@@ -582,10 +582,8 @@ private IEnumerable<CSharpAttributeData> GetReturnValueCustomAttributesToEmit()
         {
             CheckDefinitionInvariant();
 
-            ImmutableArray<CSharpAttributeData> userDefined;
+            ImmutableArray<CSharpAttributeData> userDefined = this.GetReturnTypeAttributes();
             ArrayBuilder<SynthesizedAttributeData> synthesized = null;
-
-            userDefined = this.GetReturnTypeAttributes();
             this.AddSynthesizedReturnTypeAttributes(ref synthesized);
 
             // Note that callers of this method (CCI and ReflectionEmitter) have to enumerate 
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs b/src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs
index da185b6ee18cf..cfbad7e754c4b 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs
@@ -287,12 +287,15 @@ Cci.ITypeReference Cci.ITypeDefinition.GetBaseClass(EmitContext context)
                                                                    diagnostics: context.Diagnostics) : null;
         }
 
-        IEnumerable<Cci.IEventDefinition> Cci.ITypeDefinition.Events
+        IEnumerable<Cci.IEventDefinition> Cci.ITypeDefinition.GetEvents(EmitContext context)
         {
-            get
+            CheckDefinitionInvariant();
+            foreach (var e in GetEventsToEmit())
             {
-                CheckDefinitionInvariant();
-                return GetEventsToEmit();
+                if (e.ShouldInclude(context))
+                {
+                    yield return e;
+                }
             }
         }
 
@@ -322,6 +325,7 @@ internal virtual IEnumerable<EventSymbol> GetEventsToEmit()
 
             foreach (var member in this.GetMembers())
             {
+                // PROTOTYPE(refout) Do something here?
                 if (member.Kind == SymbolKind.Method)
                 {
                     var method = (MethodSymbol)member;
@@ -389,9 +393,15 @@ internal virtual IEnumerable<EventSymbol> GetEventsToEmit()
         {
             CheckDefinitionInvariant();
 
+            // All fields in a struct should be emitted
+            bool isStruct = this.IsStructType();
+
             foreach (var f in GetFieldsToEmit())
             {
-                yield return f;
+                if (isStruct || f.ShouldInclude(context))
+                {
+                    yield return f;
+                }
             }
 
             IEnumerable<Cci.IFieldDefinition> generated = ((PEModuleBuilder)context.Module).GetSynthesizedFields(this);
@@ -400,7 +410,10 @@ internal virtual IEnumerable<EventSymbol> GetEventsToEmit()
             {
                 foreach (var f in generated)
                 {
-                    yield return f;
+                    if (isStruct || f.ShouldInclude(context))
+                    {
+                        yield return f;
+                    }
                 }
             }
         }
@@ -630,7 +643,10 @@ internal virtual bool IsMetadataSealed
             foreach (var method in this.GetMethodsToEmit())
             {
                 Debug.Assert((object)method != null);
-                yield return method;
+                if (method.ShouldInclude(context))
+                {
+                    yield return method;
+                }
             }
 
             IEnumerable<Cci.IMethodDefinition> generated = ((PEModuleBuilder)context.Module).GetSynthesizedMethods(this);
@@ -639,7 +655,10 @@ internal virtual bool IsMetadataSealed
             {
                 foreach (var m in generated)
                 {
-                    yield return m;
+                    if (m.ShouldInclude(context))
+                    {
+                        yield return m;
+                    }
                 }
             }
         }
@@ -704,7 +723,10 @@ internal virtual IEnumerable<MethodSymbol> GetMethodsToEmit()
             foreach (var property in this.GetPropertiesToEmit())
             {
                 Debug.Assert((object)property != null);
-                yield return property;
+                if (property.ShouldInclude(context))
+                {
+                    yield return property;
+                }
             }
 
             IEnumerable<Cci.IPropertyDefinition> generated = ((PEModuleBuilder)context.Module).GetSynthesizedProperties(this);
@@ -713,7 +735,10 @@ internal virtual IEnumerable<MethodSymbol> GetMethodsToEmit()
             {
                 foreach (var m in generated)
                 {
-                    yield return m;
+                    if (m.ShouldInclude(context))
+                    {
+                        yield return m;
+                    }
                 }
             }
         }
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs b/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
index 60b6fb3d1412d..1f6765b2b9526 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
@@ -83,9 +83,10 @@ internal sealed override Cci.ICustomAttribute SynthesizeAttribute(WellKnownMembe
             return Compilation.TrySynthesizeAttribute(attributeConstructor);
         }
 
-        public sealed override IEnumerable<Cci.ICustomAttribute> GetSourceAssemblyAttributes()
+        public sealed override IEnumerable<Cci.ICustomAttribute> GetSourceAssemblyAttributes(bool isRefAssembly)
         {
-            return SourceModule.ContainingSourceAssembly.GetCustomAttributesToEmit(this.CompilationState, emittingAssemblyAttributesInNetModule: OutputKind.IsNetModule());
+            return SourceModule.ContainingSourceAssembly
+                .GetCustomAttributesToEmit(this.CompilationState, isRefAssembly, emittingAssemblyAttributesInNetModule: OutputKind.IsNetModule());
         }
 
         public sealed override IEnumerable<Cci.SecurityAttribute> GetSourceAssemblySecurityAttributes()
@@ -358,9 +359,9 @@ internal virtual bool TryGetAnonymousTypeName(NamedTypeSymbol template, out stri
             return false;
         }
 
-        internal sealed override ImmutableArray<Cci.INamespaceTypeDefinition> GetAnonymousTypes()
+        internal sealed override ImmutableArray<Cci.INamespaceTypeDefinition> GetAnonymousTypes(EmitContext context)
         {
-            if (EmitOptions.EmitMetadataOnly)
+            if (context.MetadataOnly)
             {
                 return ImmutableArray<Cci.INamespaceTypeDefinition>.Empty;
             }
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/SourceAssemblySymbolAdapter.cs b/src/Compilers/CSharp/Portable/Emitter/Model/SourceAssemblySymbolAdapter.cs
new file mode 100644
index 0000000000000..e93fc7cdcc63f
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/SourceAssemblySymbolAdapter.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+
+namespace Microsoft.CodeAnalysis.CSharp.Symbols
+{
+    internal partial class SourceAssemblySymbol
+    {
+        internal IEnumerable<CSharpAttributeData> GetCustomAttributesToEmit(ModuleCompilationState compilationState, bool emittingRefAssembly, bool emittingAssemblyAttributesInNetModule)
+        {
+            CheckDefinitionInvariant();
+
+            ImmutableArray<CSharpAttributeData> userDefined = this.GetAttributes();
+            ArrayBuilder<SynthesizedAttributeData> synthesized = null;
+            this.AddSynthesizedAttributes(compilationState, ref synthesized);
+
+            if (emittingRefAssembly && !HasReferenceAssemblyAttribute)
+            {
+                var referenceAssemblyAttribute = this.DeclaringCompilation
+                    .TrySynthesizeAttribute(WellKnownMember.System_Runtime_CompilerServices_ReferenceAssemblyAttribute__ctor, isOptionalUse: true);
+                Symbol.AddSynthesizedAttribute(ref synthesized, referenceAssemblyAttribute);
+            }
+
+            // Note that callers of this method (CCI and ReflectionEmitter) have to enumerate
+            // all items of the returned iterator, otherwise the synthesized ArrayBuilder may leak.
+            return GetCustomAttributesToEmit(userDefined, synthesized, isReturnType: false, emittingAssemblyAttributesInNetModule: emittingAssemblyAttributesInNetModule);
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/SymbolAdapter.cs b/src/Compilers/CSharp/Portable/Emitter/Model/SymbolAdapter.cs
index d1c10b1df43d0..1395f36244021 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/SymbolAdapter.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/SymbolAdapter.cs
@@ -66,6 +66,7 @@ internal virtual IEnumerable<CSharpAttributeData> GetCustomAttributesToEmit(Modu
         internal IEnumerable<CSharpAttributeData> GetCustomAttributesToEmit(ModuleCompilationState compilationState, bool emittingAssemblyAttributesInNetModule)
         {
             CheckDefinitionInvariant();
+            Debug.Assert(this.Kind != SymbolKind.Assembly);
 
             ImmutableArray<CSharpAttributeData> userDefined;
             ArrayBuilder<SynthesizedAttributeData> synthesized = null;
diff --git a/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypesManager.cs b/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypesManager.cs
index 7d15930176980..2e41a059aaf81 100644
--- a/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypesManager.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypesManager.cs
@@ -331,7 +331,7 @@ private EmbeddedType EmbedType(
             // Therefore, the following check can be as simple as:
             Debug.Assert(!IsFrozen, "Set of embedded types is frozen.");
 
-            var noPiaIndexer = new Cci.NoPiaReferenceIndexer(new EmitContext(ModuleBeingBuilt, syntaxNodeOpt, diagnostics));
+            var noPiaIndexer = new Cci.NoPiaReferenceIndexer(new EmitContext(ModuleBeingBuilt, syntaxNodeOpt, diagnostics, metadataOnly: false, includePrivateMembers: true));
 
             // Make sure we embed all types referenced by the type declaration: implemented interfaces, etc.
             noPiaIndexer.VisitTypeDefinitionNoMembers(embedded);
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs
index 4cc0f8a9bea23..48f86ecbd1c2e 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs
@@ -8,7 +8,6 @@
 using System.Linq;
 using System.Reflection;
 using System.Threading;
-using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -20,7 +19,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Symbols
     /// <summary>
     /// Represents an assembly built by compiler.
     /// </summary>
-    internal sealed class SourceAssemblySymbol : MetadataOrSourceAssemblySymbol, ISourceAssemblySymbolInternal, IAttributeTargetSymbol
+    internal sealed partial class SourceAssemblySymbol : MetadataOrSourceAssemblySymbol, ISourceAssemblySymbolInternal, IAttributeTargetSymbol
     {
         /// <summary>
         /// A Compilation the assembly is created for.
@@ -730,7 +729,7 @@ private void ValidateIVTPublicKeys(DiagnosticBag diagnostics)
         /// Forces binding and decoding of attributes.
         /// This property shouldn't be accessed during binding as it can lead to attribute binding cycle.
         /// </remarks>
-        private bool InternalsAreVisible
+        public bool InternalsAreVisible
         {
             get
             {
@@ -1696,6 +1695,15 @@ private bool HasDebuggableAttribute
             }
         }
 
+        private bool HasReferenceAssemblyAttribute
+        {
+            get
+            {
+                CommonAssemblyWellKnownAttributeData assemblyData = this.GetSourceDecodedWellKnownAttributeData();
+                return assemblyData != null && assemblyData.HasReferenceAssemblyAttribute;
+            }
+        }
+
         internal override void AddSynthesizedAttributes(ModuleCompilationState compilationState, ref ArrayBuilder<SynthesizedAttributeData> attributes)
         {
             base.AddSynthesizedAttributes(compilationState, ref attributes);
@@ -2264,6 +2272,10 @@ private void DecodeWellKnownAttribute(ref DecodeWellKnownAttributeArguments<Attr
             {
                 arguments.GetOrCreateData<CommonAssemblyWellKnownAttributeData>().HasCompilationRelaxationsAttribute = true;
             }
+            else if (attribute.IsTargetAttribute(this, AttributeDescription.ReferenceAssemblyAttribute))
+            {
+                arguments.GetOrCreateData<CommonAssemblyWellKnownAttributeData>().HasReferenceAssemblyAttribute = true;
+            }
             else if (attribute.IsTargetAttribute(this, AttributeDescription.RuntimeCompatibilityAttribute))
             {
                 bool wrapNonExceptionThrows = true;
diff --git a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
index 489f10ade08e8..2f5ba3d35484d 100644
--- a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
+++ b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
@@ -9006,8 +9006,8 @@ public static void Main()
             Assert.True(File.Exists(exe));
 
             MetadataReaderUtils.VerifyPEMetadata(exe,
-                new[] { "TypeDef:<Module>", "TypeDef:C" },
-                new[] { "MethodDef: Void Main()", "MethodDef: Void .ctor()" },
+                new[] { "TypeDefinition:<Module>", "TypeDefinition:C" },
+                new[] { "MethodDefinition:Void Main()", "MethodDefinition:Void .ctor()" },
                 new[] { "CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute" }
                 );
 
@@ -9036,54 +9036,18 @@ public static void Main()
             Assert.True(File.Exists(refDll));
 
             // The types and members that are included needs further refinement.
-            // ReferenceAssemblyAttribute is missing.
             // See issue https://github.com/dotnet/roslyn/issues/17612
             MetadataReaderUtils.VerifyPEMetadata(refDll,
-                new[] { "TypeDef:<Module>", "TypeDef:C" },
-                new[] { "MethodDef: Void Main()", "MethodDef: Void .ctor()" },
-                new[] { "CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute" }
+                new[] { "TypeDefinition:<Module>", "TypeDefinition:C" },
+                new[] { "MethodDefinition:Void Main()", "MethodDefinition:Void .ctor()" },
+                new[] { "CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "ReferenceAssemblyAttribute" }
                 );
 
-            VerifyNullReferenceException(refDir, "a.dll");
-
             // Clean up temp files
             CleanupAllGeneratedFiles(dir.Path);
             CleanupAllGeneratedFiles(refDir.Path);
         }
 
-        /// <summary>
-        /// Calls C.Main() on the program and verifies that a null reference exception is thrown.
-        /// </summary>
-        private static void VerifyNullReferenceException(TempDirectory dir, string programName)
-        {
-            var src = dir.CreateFile("verifier.cs");
-            src.WriteAllText(@"
-class Verifier
-{
-    public static void Main()
-    {
-        try
-        {
-            C.Main();
-        }
-        catch(System.NullReferenceException)
-        {
-            System.Console.Write(""Got expected exception"");
-        }
-    }
-}");
-
-            var outWriter = new StringWriter(CultureInfo.InvariantCulture);
-            var csc = new MockCSharpCompiler(null, dir.Path,
-                new[] { "/nologo", "/out:verifier.exe", $"/reference:{programName}", "verifier.cs" });
-
-            int exitCode = csc.Run(outWriter);
-            Assert.Equal(0, exitCode);
-            string dirPath = dir.ToString();
-            string output = ProcessUtilities.RunAndGetOutput(Path.Combine(dirPath, "verifier.exe"), startFolder: dirPath, expectedRetCode: 0);
-            Assert.Equal("Got expected exception", output);
-        }
-
         [Fact]
         public void RefOutWithError()
         {
@@ -9118,6 +9082,7 @@ public void RefOnly()
 
             var src = dir.CreateFile("a.cs");
             src.WriteAllText(@"
+using System;
 class C
 {
     /// <summary>Main method</summary>
@@ -9125,24 +9090,30 @@ public static void Main()
     {
         error(); // semantic error in method body
     }
+    private event Action E1
+    {
+        add { }
+        remove { }
+    }
+    private event Action E2;
 }");
 
             var outWriter = new StringWriter(CultureInfo.InvariantCulture);
             var csc = new MockCSharpCompiler(null, dir.Path,
                 new[] { "/nologo", "/out:a.dll", "/refonly", "/debug", "/deterministic", "/doc:doc.xml", "a.cs" });
             int exitCode = csc.Run(outWriter);
+            Assert.Equal("", outWriter.ToString());
             Assert.Equal(0, exitCode);
 
             var refDll = Path.Combine(dir.Path, "a.dll");
             Assert.True(File.Exists(refDll));
 
             // The types and members that are included needs further refinement.
-            // ReferenceAssemblyAttribute is missing.
             // See issue https://github.com/dotnet/roslyn/issues/17612
             MetadataReaderUtils.VerifyPEMetadata(refDll,
-                new[] { "TypeDef:<Module>", "TypeDef:C" },
-                new[] { "MethodDef: Void Main()", "MethodDef: Void .ctor()" },
-                new[] { "CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute" }
+                new[] { "TypeDefinition:<Module>", "TypeDefinition:C" },
+                new[] { "MethodDefinition:Void Main()", "MethodDefinition:Void .ctor()" },
+                new[] { "CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "ReferenceAssemblyAttribute" }
                 );
 
             var pdb = Path.Combine(dir.Path, "a.pdb");
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Assembly.cs b/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Assembly.cs
index 29c448c524456..8169f56bbd693 100644
--- a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Assembly.cs
+++ b/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Assembly.cs
@@ -954,7 +954,8 @@ private static void TestDuplicateAssemblyAttributesNotEmitted(AssemblySymbol ass
             // We should get only unique netmodule/assembly attributes here, duplicate ones should not be emitted.
             int expectedEmittedAttrsCount = expectedSrcAttrCount - expectedDuplicateAttrCount;
 
-            var allEmittedAttrs = assembly.GetCustomAttributesToEmit(new ModuleCompilationState(), emittingAssemblyAttributesInNetModule: false);
+            var allEmittedAttrs = ((SourceAssemblySymbol)assembly).GetCustomAttributesToEmit(new ModuleCompilationState(),
+                emittingRefAssembly: false, emittingAssemblyAttributesInNetModule: false);
             var emittedAttrs = allEmittedAttrs.Where(a => string.Equals(a.AttributeClass.Name, attrTypeName, StringComparison.Ordinal)).AsImmutable();
 
             Assert.Equal(expectedEmittedAttrsCount, emittedAttrs.Length);
@@ -1243,7 +1244,8 @@ static void Main(string[] args) { }
                expectedDuplicateAttrCount: 1,
                attrTypeName: "AssemblyTitleAttribute");
 
-            var attrs = consoleappCompilation.Assembly.GetCustomAttributesToEmit(new ModuleCompilationState(), emittingAssemblyAttributesInNetModule: false);
+            var attrs = ((SourceAssemblySymbol)consoleappCompilation.Assembly).GetCustomAttributesToEmit(new ModuleCompilationState(),
+                emittingRefAssembly: false, emittingAssemblyAttributesInNetModule: false);
             foreach (var a in attrs)
             {
                 switch (a.AttributeClass.Name)
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/WellKnownAttributesTestBase.cs b/src/Compilers/CSharp/Test/Emit/Attributes/WellKnownAttributesTestBase.cs
index 10d44a7cf2c09..332fe419da9ad 100644
--- a/src/Compilers/CSharp/Test/Emit/Attributes/WellKnownAttributesTestBase.cs
+++ b/src/Compilers/CSharp/Test/Emit/Attributes/WellKnownAttributesTestBase.cs
@@ -87,7 +87,7 @@ internal static void VerifyParamArrayAttribute(ParameterSymbol parameter, Source
             var paramArrayAttributeCtor = (MethodSymbol)emitModule.Compilation.GetWellKnownTypeMember(WellKnownMember.System_ParamArrayAttribute__ctor);
             bool found = false;
 
-            var context = new EmitContext(emitModule, null, new DiagnosticBag());
+            var context = new EmitContext(emitModule, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
 
             foreach (Microsoft.Cci.ICustomAttribute attr in parameter.GetSynthesizedAttributes())
             {
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTests.cs
index 00aedb211f357..27176d1dd9d1b 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTests.cs
@@ -12826,6 +12826,7 @@ static System.Action M()
                 compilation: compilation,
                 moduleBeingBuiltOpt: module,
                 emittingPdb: false,
+                emitTestCoverageData: false,
                 hasDeclarationErrors: false,
                 diagnostics: diagnostics,
                 filterOpt: null,
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs
index 52e573a6b45d4..c15e49dde5932 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs
@@ -19852,7 +19852,7 @@ static void Main()
             {
                 var reader = block.MetadataReader;
                 AssertEx.SetEqual(new[] { "mscorlib 4.0", "System.ValueTuple 4.0" }, reader.DumpAssemblyReferences());
-                Assert.Contains("ValueTuple`2, System, AssemblyRef:System.ValueTuple", reader.DumpTypeReferences());
+                Assert.Contains("ValueTuple`2, System, AssemblyReference:System.ValueTuple", reader.DumpTypeReferences());
             }
 
             // emit with pdb
@@ -19861,7 +19861,7 @@ static void Main()
                 {
                     var reader = assembly.GetMetadataReader();
                     AssertEx.SetEqual(new[] { "mscorlib 4.0", "System.ValueTuple 4.0" }, reader.DumpAssemblyReferences());
-                    Assert.Contains("ValueTuple`2, System, AssemblyRef:System.ValueTuple", reader.DumpTypeReferences());
+                    Assert.Contains("ValueTuple`2, System, AssemblyReference:System.ValueTuple", reader.DumpTypeReferences());
                 });
             // no assertion in MetadataWriter
         }
@@ -19892,7 +19892,7 @@ static void Main()
             {
                 var reader = block.MetadataReader;
                 AssertEx.SetEqual(new[] { "mscorlib 4.0", "lib 0.0" }, reader.DumpAssemblyReferences());
-                Assert.Contains("ReferencedType, , AssemblyRef:lib", reader.DumpTypeReferences());
+                Assert.Contains("ReferencedType, , AssemblyReference:lib", reader.DumpTypeReferences());
             }
 
             // emit with pdb
@@ -19901,7 +19901,7 @@ static void Main()
                 {
                     var reader = assembly.GetMetadataReader();
                     AssertEx.SetEqual(new[] { "mscorlib 4.0", "lib 0.0" }, reader.DumpAssemblyReferences());
-                    Assert.Contains("ReferencedType, , AssemblyRef:lib", reader.DumpTypeReferences());
+                    Assert.Contains("ReferencedType, , AssemblyReference:lib", reader.DumpTypeReferences());
                 });
             // no assertion in MetadataWriter
         }
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
index 20b13f8ac0e1c..69dc56b4444cd 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
@@ -8,6 +8,7 @@
 using System.Reflection.Metadata;
 using System.Reflection.Metadata.Ecma335;
 using System.Reflection.PortableExecutable;
+using System.Text;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
@@ -237,41 +238,335 @@ public static void Main()
             }
         }
 
+        [Fact]
+        public void RefAssembly_HasReferenceAssemblyAttribute()
+        {
+            var emitRefAssembly = EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false);
+
+            Action<PEAssembly> assemblyValidator = assembly =>
+            {
+                var reader = assembly.GetMetadataReader();
+                var attributes = reader.GetAssemblyDefinition().GetCustomAttributes();
+                AssertEx.Equal(new[] {
+                        "MemberReference:Void System.Runtime.CompilerServices.CompilationRelaxationsAttribute.ctor(Int32)",
+                        "MemberReference:Void System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.ctor()",
+                        "MemberReference:Void System.Diagnostics.DebuggableAttribute.ctor(DebuggingModes)",
+                        "MemberReference:Void System.Runtime.CompilerServices.ReferenceAssemblyAttribute.ctor()"
+                    },
+                    attributes.Select(a => MetadataReaderUtils.Dump(reader, reader.GetCustomAttribute(a).Constructor)));
+            };
+
+            CompileAndVerify("", emitOptions: emitRefAssembly, assemblyValidator: assemblyValidator);
+        }
+
+        [Fact]
+        public void RefAssembly_HandlesMissingReferenceAssemblyAttribute()
+        {
+            var emitRefAssembly = EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false);
+
+            Action<PEAssembly> assemblyValidator = assembly =>
+            {
+                var reader = assembly.GetMetadataReader();
+                var attributes = reader.GetAssemblyDefinition().GetCustomAttributes();
+                AssertEx.SetEqual(attributes.Select(a => MetadataReaderUtils.Dump(reader, reader.GetCustomAttribute(a).Constructor)),
+                    new string[] {
+                        "MemberReference:Void System.Runtime.CompilerServices.CompilationRelaxationsAttribute.ctor(Int32)",
+                        "MemberReference:Void System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.ctor()",
+                        "MemberReference:Void System.Diagnostics.DebuggableAttribute.ctor(DebuggingModes)"
+                    });
+            };
+
+            var comp = CreateCompilationWithMscorlib("");
+            comp.MakeMemberMissing(WellKnownMember.System_Runtime_CompilerServices_ReferenceAssemblyAttribute__ctor);
+            CompileAndVerify(compilation: comp, emitOptions: emitRefAssembly, assemblyValidator: assemblyValidator);
+        }
+
+        [Fact]
+        public void RefAssembly_ReferenceAssemblyAttributeAlsoInSource()
+        {
+            var emitRefAssembly = EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false);
+
+            Action<PEAssembly> assemblyValidator = assembly =>
+            {
+                var reader = assembly.GetMetadataReader();
+                var attributes = reader.GetAssemblyDefinition().GetCustomAttributes();
+                AssertEx.Equal(new string[] {
+                        "MemberReference:Void System.Runtime.CompilerServices.CompilationRelaxationsAttribute.ctor(Int32)",
+                        "MemberReference:Void System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.ctor()",
+                        "MemberReference:Void System.Diagnostics.DebuggableAttribute.ctor(DebuggingModes)",
+                        "MemberReference:Void System.Runtime.CompilerServices.ReferenceAssemblyAttribute.ctor()"
+                    },
+                    attributes.Select(a => MetadataReaderUtils.Dump(reader, reader.GetCustomAttribute(a).Constructor)));
+            };
+            string source = @"[assembly:System.Runtime.CompilerServices.ReferenceAssembly()]";
+            CompileAndVerify(source, emitOptions: emitRefAssembly, assemblyValidator: assemblyValidator);
+        }
+
+        [Theory]
+        [InlineData("public int M() { return 1; }", "public int M() { return 2; }", Match.BothMetadataAndRefOut)]
+        [InlineData("public int M() { return 1; }", "public int M() { error(); }", Match.BothMetadataAndRefOut)]
+        [InlineData("private void M() { }", "", Match.RefOut)]
+        [InlineData("internal void M() { }", "", Match.RefOut)]
+        [InlineData("private void M() { dynamic x = 1; }", "", Match.RefOut)] // no reference added from method bodies
+        [InlineData(@"private void M() { var x = new { id = 1 }; }", "", Match.RefOut)]
+        [InlineData("private int P { get { Error(); } set { Error(); } }", "", Match.RefOut)] // errors in methods bodies don't matter
+        [InlineData("public int P { get; set; }", "", Match.Different)]
+        [InlineData("protected int P { get; set; }", "", Match.Different)]
+        [InlineData("private int P { get; set; }", "", Match.RefOut)] // private auto-property and underlying field are removed
+        [InlineData("internal int P { get; set; }", "", Match.RefOut)]
+        [InlineData("private event Action E { add { Error(); } remove { Error(); } }", "", Match.RefOut)]
+        [InlineData("internal event Action E { add { Error(); } remove { Error(); } }", "", Match.RefOut)]
+        [InlineData("private class C2 { }", "", Match.Different)] // all types are included
+        [InlineData("private struct S { }", "", Match.Different)]
+        [InlineData("public struct S { private int i; }", "public struct S { }", Match.Different)]
+        [InlineData("private int i;", "", Match.RefOut)]
+        [InlineData("public C() { }", "", Match.BothMetadataAndRefOut)]
+        //[InlineData("public int NoBody();", "public int NoBody() { }", Match.BothMetadataAndRefOut)] // PROTOTYPE(refout) Further refinement https://github.com/dotnet/roslyn/issues/17612
+        public void RefAssembly_InvariantToSomeChanges(string left, string right, Match expectedMatch)
+        {
+            string sourceTemplate = @"
+using System;
+public class C
+{
+    CHANGE
+}
+";
+
+            CompareAssemblies(sourceTemplate, left, right, expectedMatch, includePrivateMembers: true);
+            CompareAssemblies(sourceTemplate, left, right, expectedMatch, includePrivateMembers: false);
+        }
+
         [Theory]
-        [InlineData("public int M() { return 1; }", "public int M() { return 2; }", true)]
-        [InlineData("public int M() { return 1; }", "public int M() { error(); }", true)]
-        [InlineData("", "private void M() { }", false)] // Should be true. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
-        [InlineData("internal void M() { }", "", false)]
-        [InlineData("public struct S { private int i; }", "public struct S { }", false)]
-        public void RefAssembly_InvariantToSomeChanges(string change1, string change2, bool expectMatch)
+        [InlineData("internal void M() { }", "", Match.Different)]
+        public void RefAssembly_InvariantToSomeChangesWithInternalsVisibleTo(string left, string right, Match expectedMatch)
         {
             string sourceTemplate = @"
+using System.Runtime.CompilerServices;
+[assembly: InternalsVisibleToAttribute(""Friend"")]
 public class C
 {
     CHANGE
 }
 ";
+
+            CompareAssemblies(sourceTemplate, left, right, expectedMatch, includePrivateMembers: true);
+            CompareAssemblies(sourceTemplate, left, right, expectedMatch, includePrivateMembers: false);
+        }
+
+        public enum Match
+        {
+            BothMetadataAndRefOut,
+            RefOut,
+            Different
+        }
+
+        /// <summary>
+        /// Are the metadata-only assemblies identical with two source code modifications?
+        /// Metadata-only assemblies can either include private/internal members or not.
+        /// </summary>
+        private void CompareAssemblies(string sourceTemplate, string change1, string change2, Match expectedMatch, bool includePrivateMembers)
+        {
+            bool expectMatch = includePrivateMembers ?
+                expectedMatch == Match.BothMetadataAndRefOut :
+                (expectedMatch == Match.BothMetadataAndRefOut || expectedMatch == Match.RefOut);
+
             string name = GetUniqueName();
             string source1 = sourceTemplate.Replace("CHANGE", change1);
             CSharpCompilation comp1 = CreateCompilationWithMscorlib(Parse(source1),
                 options: TestOptions.DebugDll.WithDeterministic(true), assemblyName: name);
-            ImmutableArray<byte> image1 = comp1.EmitToArray(EmitOptions.Default.WithEmitMetadataOnly(true));
+            ImmutableArray<byte> image1 = comp1.EmitToArray(EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(includePrivateMembers));
 
             var source2 = sourceTemplate.Replace("CHANGE", change2);
             Compilation comp2 = CreateCompilationWithMscorlib(Parse(source2),
                 options: TestOptions.DebugDll.WithDeterministic(true), assemblyName: name);
-            ImmutableArray<byte> image2 = comp2.EmitToArray(EmitOptions.Default.WithEmitMetadataOnly(true));
+            ImmutableArray<byte> image2 = comp2.EmitToArray(EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(includePrivateMembers));
 
             if (expectMatch)
             {
-                AssertEx.Equal(image1, image2);
+                AssertEx.Equal(image1, image2, message: $"Expecting match for includePrivateMembers={includePrivateMembers} case, but differences were found.");
             }
             else
             {
-                AssertEx.NotEqual(image1, image2);
+                AssertEx.NotEqual(image1, image2, message: $"Expecting difference for includePrivateMembers={includePrivateMembers} case, but they matched.");
             }
         }
 
+        [Fact]
+        public void RefAssemblyClient_StructWithPrivateReferenceTypeField()
+        {
+            VerifyRefAssemblyClient(@"
+public struct S
+{
+    private object _field;
+    public static S GetValue() => new S() { _field = new object() };
+}",
+@"class C
+{
+    void M()
+    {
+        unsafe
+        {
+            System.Console.WriteLine(sizeof(S*));
+        }
+    }
+}",
+comp => comp.VerifyDiagnostics(
+                // (7,45): error CS0208: Cannot take the address of, get the size of, or declare a pointer to a managed type ('S')
+                //             System.Console.WriteLine(sizeof(S*));
+                Diagnostic(ErrorCode.ERR_ManagedAddr, "S*").WithArguments("S").WithLocation(7, 45)
+                ));
+        }
+
+        [Fact]
+        public void RefAssemblyClient_EmitAllNestedTypes()
+        {
+            VerifyRefAssemblyClient(@"
+public interface I1<T> { }
+public interface I2 { }
+public class A: I1<A.X>
+{
+    private class X: I2 { }
+}",
+@"class C
+{
+    I1<I2> M(A a)
+    {
+        return (I1<I2>)a;
+    }
+}",
+comp => comp.VerifyDiagnostics());
+        }
+
+        [Fact]
+        public void RefAssemblyClient_EmitAllTypes()
+        {
+            VerifyRefAssemblyClient(@"
+public interface I1<T> { }
+public interface I2 { }
+public class A: I1<X> { }
+internal class X: I2 { }
+",
+@"class C
+{
+    I1<I2> M(A a)
+    {
+        return (I1<I2>)a;
+    }
+}",
+comp => comp.VerifyDiagnostics());
+        }
+
+        [Fact]
+        public void RefAssemblyClient_StructWithPrivateGenericField()
+        {
+            VerifyRefAssemblyClient(@"
+public struct Container<T>
+{
+    private T contained;
+}",
+@"public struct Usage
+{
+    public Container<Usage> x;
+}",
+comp => comp.VerifyDiagnostics(
+                // (3,29): error CS0523: Struct member 'Usage.x' of type 'Container<Usage>' causes a cycle in the struct layout
+                //     public Container<Usage> x;
+                Diagnostic(ErrorCode.ERR_StructLayoutCycle, "x").WithArguments("Usage.x", "Container<Usage>").WithLocation(3, 29)
+                ));
+        }
+
+        [Fact]
+        public void RefAssemblyClient_EmitAllVirtualMethods()
+        {
+
+            var comp1 = CreateCSharpCompilation("CS1",
+@"[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(""CS2"")]
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(""CS3"")]
+public abstract class C1
+{
+    internal abstract void M();
+}",
+                referencedAssemblies: new[] { MscorlibRef });
+            comp1.VerifyDiagnostics();
+            var image1 = comp1.EmitToImageReference(EmitOptions.Default);
+
+            var comp2 = CreateCSharpCompilation("CS2",
+@"public abstract class C2 : C1
+{
+    internal override void M() { }
+}",
+              referencedAssemblies: new[] { MscorlibRef, image1 });
+            var image2 = comp2.EmitToImageReference(EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false));
+
+            // If internal virtual methods were not included in ref assemblies, then C3 could not be concrete and would report
+            // error CS0534: 'C3' does not implement inherited abstract member 'C1.M()'
+
+            var comp3 = CreateCSharpCompilation("CS3",
+@"public class C3 : C2
+{
+}",
+                referencedAssemblies: new[] { MscorlibRef, image1, image2 });
+            comp3.VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void RefAssemblyClient_StructWithPrivateIntField()
+        {
+            VerifyRefAssemblyClient(@"
+public struct S
+{
+    private int i;
+}",
+@"class C
+{
+    string M()
+    {
+        S s;
+        return s.ToString();
+    }
+}",
+comp => comp.VerifyDiagnostics(
+                // (6,16): error CS0165: Use of unassigned local variable 's'
+                //         return s.ToString();
+                Diagnostic(ErrorCode.ERR_UseDefViolation, "s").WithArguments("s").WithLocation(6, 16)
+                ));
+        }
+
+        private void VerifyRefAssemblyClient(string lib_cs, string client_cs, Action<CSharpCompilation> validator, int debugFlag = -1)
+        {
+            // Whether the library is compiled in full, as metadata-only, or as a ref assembly should be transparent
+            // to the client and the validator should be able to verify the same expectations.
+
+            if (debugFlag == -1 || debugFlag == 0)
+            {
+                VerifyRefAssemblyClient(lib_cs, client_cs, validator,
+                    EmitOptions.Default.WithEmitMetadataOnly(false));
+            }
+
+            if (debugFlag == -1 || debugFlag == 1)
+            {
+                VerifyRefAssemblyClient(lib_cs, client_cs, validator,
+                    EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(true));
+            }
+
+            if (debugFlag == -1 || debugFlag == 2)
+            {
+                VerifyRefAssemblyClient(lib_cs, client_cs, validator,
+                    EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false));
+            }
+        }
+
+        private static void VerifyRefAssemblyClient(string lib_cs, string source, Action<CSharpCompilation> validator, EmitOptions emitOptions)
+        {
+            string name = GetUniqueName();
+            var libComp = CreateCompilationWithMscorlib(Parse(lib_cs),
+                options: TestOptions.DebugDll.WithDeterministic(true), assemblyName: name);
+            var libImage = libComp.EmitToImageReference(emitOptions);
+
+            var comp = CreateCompilationWithMscorlib(source, references: new[] { libImage }, options: TestOptions.DebugDll.WithAllowUnsafe(true));
+            validator(comp);
+        }
+
         [Theory]
         [InlineData("public int M() { error(); }", true)]
         [InlineData("public int M() { error() }", false)] // Should be true. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
@@ -301,46 +596,90 @@ public class C
         public void VerifyRefAssembly()
         {
             string source = @"
-public abstract class PublicClass
+public class PublicClass
 {
-    public void PublicMethod() { System.Console.Write(""Hello""); }
+    public void PublicMethod() { System.Console.Write(new { anonymous = 1 }); }
     private void PrivateMethod() { System.Console.Write(""Hello""); }
     protected void ProtectedMethod() { System.Console.Write(""Hello""); }
     internal void InternalMethod() { System.Console.Write(""Hello""); }
-    public abstract void AbstractMethod();
 }
 ";
             CSharpCompilation comp = CreateCompilation(source, references: new[] { MscorlibRef },
                 options: TestOptions.DebugDll.WithDeterministic(true));
 
-            var emitRefOnly = EmitOptions.Default.WithEmitMetadataOnly(true);
+            // verify metadata (types, members, attributes) of the regular assembly
+            CompileAndVerify(comp, emitOptions: EmitOptions.Default, verify: true);
+
+            var realImage = comp.EmitToImageReference(EmitOptions.Default);
+            var compWithReal = CreateCompilation("", references: new[] { MscorlibRef, realImage },
+                options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
+            AssertEx.Equal(
+                compWithReal.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMembers().Select(m => m.ToDisplayString()),
+                new[] { "<Module>", "<>f__AnonymousType0<<anonymous>j__TPar>", "PublicClass" });
+
+            AssertEx.Equal(
+                ((NamedTypeSymbol)compWithReal.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMember("PublicClass")).GetMembers()
+                    .Select(m => m.ToTestDisplayString()),
+                new[] { "void PublicClass.PublicMethod()", "void PublicClass.PrivateMethod()",
+                    "void PublicClass.ProtectedMethod()", "void PublicClass.InternalMethod()",
+                    "PublicClass..ctor()" });
+
+            AssertEx.Equal(compWithReal.SourceModule.GetReferencedAssemblySymbols().Last().GetAttributes().Select(a => a.AttributeClass.ToTestDisplayString()),
+                new[] { "System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
+                    "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
+                    "System.Diagnostics.DebuggableAttribute" });
 
-            var verifier = CompileAndVerify(comp, emitOptions: emitRefOnly, verify: true);
+            // verify metadata (types, members, attributes) of the metadata-only assembly
+            var emitMetadataOnly = EmitOptions.Default.WithEmitMetadataOnly(true);
+            CompileAndVerify(comp, emitOptions: emitMetadataOnly, verify: true);
 
-            // verify metadata (types, members, attributes)
-            var image = comp.EmitToImageReference(emitRefOnly);
-            var comp2 = CreateCompilation("", references: new[] { MscorlibRef, image },
+            var metadataImage = comp.EmitToImageReference(emitMetadataOnly);
+            var compWithMetadata = CreateCompilation("", references: new[] { MscorlibRef, metadataImage },
                 options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
-            AssemblySymbol assembly = comp2.SourceModule.GetReferencedAssemblySymbols().Last();
-            var members = assembly.GlobalNamespace.GetMembers();
-            AssertEx.SetEqual(members.Select(m => m.ToDisplayString()),
+            AssertEx.Equal(
+                compWithMetadata.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMembers().Select(m => m.ToDisplayString()),
                 new[] { "<Module>", "PublicClass" });
 
-            AssertEx.SetEqual(
-                ((NamedTypeSymbol)assembly.GlobalNamespace.GetMember("PublicClass")).GetMembers()
+            AssertEx.Equal(
+                ((NamedTypeSymbol)compWithMetadata.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMember("PublicClass")).GetMembers()
                     .Select(m => m.ToTestDisplayString()),
                 new[] { "void PublicClass.PublicMethod()", "void PublicClass.PrivateMethod()",
-                    "void PublicClass.InternalMethod()", "void PublicClass.ProtectedMethod()",
-                    "void PublicClass.AbstractMethod()", "PublicClass..ctor()" });
+                    "void PublicClass.ProtectedMethod()", "void PublicClass.InternalMethod()",
+                    "PublicClass..ctor()" });
 
-            AssertEx.SetEqual(assembly.GetAttributes().Select(a => a.AttributeClass.ToTestDisplayString()),
+            AssertEx.Equal(compWithMetadata.SourceModule.GetReferencedAssemblySymbols().Last().GetAttributes().Select(a => a.AttributeClass.ToTestDisplayString()),
                 new[] { "System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
                     "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
                     "System.Diagnostics.DebuggableAttribute" });
 
-            var peImage = comp.EmitToArray(emitRefOnly);
-            MetadataReaderUtils.AssertEmptyOrThrowNull(peImage);
+            MetadataReaderUtils.AssertEmptyOrThrowNull(comp.EmitToArray(emitMetadataOnly));
+
+            // verify metadata (types, members, attributes) of the metadata-only assembly
+            var emitRefOnly = EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false);
+            CompileAndVerify(comp, emitOptions: emitRefOnly, verify: true);
+
+            var refImage = comp.EmitToImageReference(emitRefOnly);
+            var compWithRef = CreateCompilation("", references: new[] { MscorlibRef, refImage },
+                options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
+            AssertEx.Equal(
+                compWithRef.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMembers().Select(m => m.ToDisplayString()),
+                new[] { "<Module>", "PublicClass" });
+
+            AssertEx.Equal(
+                ((NamedTypeSymbol)compWithRef.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMember("PublicClass")).GetMembers()
+                    .Select(m => m.ToTestDisplayString()),
+                new[] { "void PublicClass.PublicMethod()", "void PublicClass.ProtectedMethod()", "PublicClass..ctor()" });
+
+            AssertEx.Equal(compWithRef.SourceModule.GetReferencedAssemblySymbols().Last().GetAttributes().Select(a => a.AttributeClass.ToTestDisplayString()),
+                new[] {
+                    "System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
+                    "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
+                    "System.Diagnostics.DebuggableAttribute",
+                    "System.Runtime.CompilerServices.ReferenceAssemblyAttribute" });
+
+            MetadataReaderUtils.AssertEmptyOrThrowNull(comp.EmitToArray(emitRefOnly));
         }
+
         [Fact]
         public void EmitMetadataOnly_DisallowPdbs()
         {
@@ -369,6 +708,20 @@ public void EmitMetadataOnly_DisallowMetadataPeStream()
             }
         }
 
+        [Fact]
+        public void IncludePrivateMembers_DisallowMetadataPeStream()
+        {
+            CSharpCompilation comp = CreateCompilation("", references: new[] { MscorlibRef },
+                options: TestOptions.DebugDll.WithDeterministic(true));
+
+            using (var output = new MemoryStream())
+            using (var metadataPeOutput = new MemoryStream())
+            {
+                Assert.Throws<ArgumentException>(() => comp.Emit(output, metadataPEStream: metadataPeOutput,
+                    options: EmitOptions.Default.WithIncludePrivateMembers(true)));
+            }
+        }
+
         [Fact]
         public void EmitMetadata_DisallowOutputtingNetModule()
         {
@@ -406,7 +759,7 @@ public void EmitMetadata_AllowEmbedding()
             using (var metadataOutput = new MemoryStream())
             {
                 var result = comp.Emit(output, metadataPEStream: metadataOutput,
-                    options: EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.Embedded));
+                    options: EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.Embedded).WithIncludePrivateMembers(false));
 
                 VerifyEmbeddedDebugInfo(output, new[] { DebugDirectoryEntryType.CodeView, DebugDirectoryEntryType.EmbeddedPortablePdb });
                 VerifyEmbeddedDebugInfo(metadataOutput, new DebugDirectoryEntryType[] { });
@@ -523,7 +876,7 @@ public class Class1 : CppCli.CppBase2, CppCli.CppInterface1
             var class1TypeDef = (Cci.ITypeDefinition)class1;
 
             var symbolSynthesized = class1.GetSynthesizedExplicitImplementations(CancellationToken.None);
-            var context = new EmitContext(module, null, new DiagnosticBag());
+            var context = new EmitContext(module, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
             var cciExplicit = class1TypeDef.GetExplicitImplementationOverrides(context);
             var cciMethods = class1TypeDef.GetMethods(context).Where(m => ((MethodSymbol)m).MethodKind != MethodKind.Constructor);
 
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.cs
index 373588419adbe..2c5bd19cf25a5 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.cs
@@ -434,7 +434,7 @@ static void F()
             var displayClass = peAssemblyBuilder.GetSynthesizedTypes(c).Single();
             Assert.Equal("<>c__DisplayClass0_0", displayClass.Name);
 
-            var emitContext = new EmitContext(peAssemblyBuilder, null, new DiagnosticBag());
+            var emitContext = new EmitContext(peAssemblyBuilder, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
 
             var fields = displayClass.GetFields(emitContext).ToArray();
             var x1 = fields[0];
@@ -504,7 +504,7 @@ static void F()
             var displayClass = peAssemblyBuilder.GetSynthesizedTypes(c).Single();
             Assert.Equal("<>c__DisplayClass0_0", displayClass.Name);
 
-            var emitContext = new EmitContext(peAssemblyBuilder, null, new DiagnosticBag());
+            var emitContext = new EmitContext(peAssemblyBuilder, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
 
             var fields = displayClass.GetFields(emitContext).ToArray();
             AssertEx.SetEqual(fields.Select(f => f.Name), new[] { "x1", "x2" });
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EmitMetadata.cs b/src/Compilers/CSharp/Test/Emit/Emit/EmitMetadata.cs
index 429024763cd1a..c6265c904fa5b 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EmitMetadata.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EmitMetadata.cs
@@ -1371,7 +1371,7 @@ private void CheckEnumType(NamedTypeSymbol type, Accessibility declaredAccessibi
                 var module = new PEAssemblyBuilder((SourceAssemblySymbol)sourceType.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
                     GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
 
-                var context = new EmitContext(module, null, new DiagnosticBag());
+                var context = new EmitContext(module, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
 
                 var typeDefinition = (Microsoft.Cci.ITypeDefinition)type;
                 var fieldDefinition = typeDefinition.GetFields(context).First();
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
index 146816590c3bc..259f3b388e25b 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
@@ -2547,7 +2547,7 @@ private static void Main(string[] args) { }
 
                 var extensionAttrCtor = (MethodSymbol)emitModule.Compilation.GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_ExtensionAttribute__ctor);
                 Assert.NotNull(extensionAttrCtor);
-                var context = new EmitContext(emitModule, null, new DiagnosticBag());
+                var context = new EmitContext(emitModule, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
                 Assert.Equal(extensionAttrCtor, attr.Constructor(context));
                 Assert.NotNull(extensionAttrCtor.ContainingType);
                 Assert.Equal(extensionAttrCtor.ContainingType, attr.GetType(context));
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/BaseClassTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/BaseClassTests.cs
index 97bea9381ebc4..f93efbd2d509b 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/BaseClassTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/BaseClassTests.cs
@@ -1550,7 +1550,7 @@ class C : I2 { }
             var typeDef = (Cci.ITypeDefinition)@class;
             var module = new PEAssemblyBuilder((SourceAssemblySymbol)@class.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
                 GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
-            var context = new EmitContext(module, null, new DiagnosticBag());
+            var context = new EmitContext(module, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
             var cciInterfaces = typeDef.Interfaces(context)
                 .Select(impl => impl.TypeRef).Cast<NamedTypeSymbol>().AsImmutable();
             Assert.True(cciInterfaces.SetEquals(bothInterfaces, EqualityComparer<NamedTypeSymbol>.Default));
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/MethodTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/MethodTests.cs
index 753ae4e0faaaa..43a07570061b2 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/MethodTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/MethodTests.cs
@@ -1571,7 +1571,7 @@ void I.Method() { }
             var typeDef = (Cci.ITypeDefinition)@class;
             var module = new PEAssemblyBuilder((SourceAssemblySymbol)@class.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
                 GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
-            var context = new EmitContext(module, null, new DiagnosticBag());
+            var context = new EmitContext(module, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
             var explicitOverride = typeDef.GetExplicitImplementationOverrides(context).Single();
             Assert.Equal(@class, explicitOverride.ContainingType);
             Assert.Equal(classMethod, explicitOverride.ImplementingMethod);
@@ -1615,7 +1615,7 @@ string System.IFormattable.ToString(string format, System.IFormatProvider format
             var typeDef = (Cci.ITypeDefinition)@class;
             var module = new PEAssemblyBuilder((SourceAssemblySymbol)@class.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
                GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
-            var context = new EmitContext(module, null, new DiagnosticBag());
+            var context = new EmitContext(module, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
             var explicitOverride = typeDef.GetExplicitImplementationOverrides(context).Single();
             Assert.Equal(@class, explicitOverride.ContainingType);
             Assert.Equal(classMethod, explicitOverride.ImplementingMethod);
@@ -1662,7 +1662,7 @@ class C : I
             var typeDef = (Cci.ITypeDefinition)@class;
             var module = new PEAssemblyBuilder((SourceAssemblySymbol)@class.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
                 GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
-            var context = new EmitContext(module, null, new DiagnosticBag());
+            var context = new EmitContext(module, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
             var explicitOverride = typeDef.GetExplicitImplementationOverrides(context).Single();
             Assert.Equal(@class, explicitOverride.ContainingType);
             Assert.Equal(classMethod, explicitOverride.ImplementingMethod);
@@ -1716,7 +1716,7 @@ void Namespace.I<int>.Method(int i) { }
             var typeDef = (Cci.ITypeDefinition)@class;
             var module = new PEAssemblyBuilder((SourceAssemblySymbol)@class.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
                 GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
-            var context = new EmitContext(module, null, new DiagnosticBag());
+            var context = new EmitContext(module, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
             var explicitOverride = typeDef.GetExplicitImplementationOverrides(context).Single();
             Assert.Equal(@class, explicitOverride.ContainingType);
             Assert.Equal(classMethod, explicitOverride.ImplementingMethod);
@@ -1857,7 +1857,7 @@ public class C : B
             var typeDefC = (Cci.ITypeDefinition)classC;
             var module = new PEAssemblyBuilder((SourceAssemblySymbol)classC.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
                 GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
-            var context = new EmitContext(module, null, new DiagnosticBag());
+            var context = new EmitContext(module, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
             var explicitOverride = typeDefC.GetExplicitImplementationOverrides(context).Single();
             Assert.Equal(classC, explicitOverride.ContainingType);
             Assert.Equal(methodC, explicitOverride.ImplementingMethod);
@@ -1901,7 +1901,7 @@ public class C : B
             var typeDefC = (Cci.ITypeDefinition)classC;
             var module = new PEAssemblyBuilder((SourceAssemblySymbol)classC.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
                 GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
-            var context = new EmitContext(module, null, new DiagnosticBag());
+            var context = new EmitContext(module, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
             var explicitOverride = typeDefC.GetExplicitImplementationOverrides(context).Single();
             Assert.Equal(classC, explicitOverride.ContainingType);
             Assert.Equal(methodC, explicitOverride.ImplementingMethod);
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/PropertyTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/PropertyTests.cs
index 0a6e7a54b92ab..8ff49c87a5350 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/PropertyTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/PropertyTests.cs
@@ -2468,7 +2468,7 @@ private static void CheckPropertyExplicitImplementation(NamedTypeSymbol @class,
             var module = new PEAssemblyBuilder((SourceAssemblySymbol)@class.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
                 GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
 
-            var context = new EmitContext(module, null, new DiagnosticBag());
+            var context = new EmitContext(module, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
             var explicitOverrides = typeDef.GetExplicitImplementationOverrides(context);
             Assert.Equal(2, explicitOverrides.Count());
             Assert.True(explicitOverrides.All(@override => ReferenceEquals(@class, @override.ContainingType)));
@@ -2506,7 +2506,7 @@ private static void CheckRefPropertyExplicitImplementation(NamedTypeSymbol @clas
             var module = new PEAssemblyBuilder((SourceAssemblySymbol)@class.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
                 GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
 
-            var context = new EmitContext(module, null, new DiagnosticBag());
+            var context = new EmitContext(module, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
             var explicitOverrides = typeDef.GetExplicitImplementationOverrides(context);
             Assert.Equal(1, explicitOverrides.Count());
             Assert.True(explicitOverrides.All(@override => ReferenceEquals(@class, @override.ContainingType)));
diff --git a/src/Compilers/Core/CodeAnalysisTest/Emit/EmitOptionsTests.cs b/src/Compilers/Core/CodeAnalysisTest/Emit/EmitOptionsTests.cs
index 4ec5211154bb4..6aa7389beebe0 100644
--- a/src/Compilers/Core/CodeAnalysisTest/Emit/EmitOptionsTests.cs
+++ b/src/Compilers/Core/CodeAnalysisTest/Emit/EmitOptionsTests.cs
@@ -53,7 +53,7 @@ public void WithXxx()
             TestProperty((old, value) => old.WithOutputNameOverride(value), opt => opt.OutputNameOverride, @"x.dll");
             TestProperty((old, value) => old.WithDebugInformationFormat(value), opt => opt.DebugInformationFormat, (DebugInformationFormat)2);
             TestProperty((old, value) => old.WithTolerateErrors(value), opt => opt.TolerateErrors, true);
-            TestProperty((old, value) => old.WithIncludePrivateMembers(value), opt => opt.IncludePrivateMembers, true);
+            TestProperty((old, value) => old.WithIncludePrivateMembers(value), opt => opt.IncludePrivateMembers, false);
             TestProperty((old, value) => old.WithInstrumentationKinds(value), opt => opt.InstrumentationKinds, ImmutableArray.Create(InstrumentationKind.TestCoverage));
         }
 
diff --git a/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs b/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs
index cdb32fa7adf59..1c2f34c70646a 100644
--- a/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs
+++ b/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs
@@ -10,10 +10,10 @@
 namespace Microsoft.CodeAnalysis.BuildTasks
 {
     /// <summary>
-    /// If the source and destination ref assemblies are different,
-    /// this task copies the source over to the destination.
+    /// By default, this task copies the source over to the destination. 
+    /// But if we're able to check that they are identical, the destination is left untouched.
     /// </summary>
-    public class CopyRefAssembly : Task
+    public sealed class CopyRefAssembly : Task
     {
         [Required]
         public string SourcePath { get; set; }
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
index 376bf146c519b..9a38358b5b06a 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
@@ -604,6 +604,15 @@ internal static string IconStreamUnexpectedFormat {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Including private members should not be used when emitting to the secondary assembly output..
+        /// </summary>
+        internal static string IncludingPrivateMembersUnexpectedWhenEmittingToMetadataPeStream {
+            get {
+                return ResourceManager.GetString("IncludingPrivateMembersUnexpectedWhenEmittingToMetadataPeStream", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Inconsistent language versions.
         /// </summary>
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.resx b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
index 54d4a21da6f75..5843e7ac09b72 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.resx
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
@@ -336,6 +336,9 @@
   <data name="MetadataPeStreamUnexpectedWhenEmittingMetadataOnly" xml:space="preserve">
     <value>Metadata PE stream should not be given when emitting metadata only.</value>
   </data>
+  <data name="IncludingPrivateMembersUnexpectedWhenEmittingToMetadataPeStream" xml:space="preserve">
+    <value>Including private members should not be used when emitting to the secondary assembly output.</value>
+  </data>
   <data name="EmbeddingPdbUnexpectedWhenEmittingMetadata" xml:space="preserve">
     <value>Embedding PDB is not allowed when emitting metadata.</value>
   </data>
diff --git a/src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs b/src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs
index 38feca8508a25..3691be8ca02ea 100644
--- a/src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs
+++ b/src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs
@@ -469,7 +469,7 @@ internal MappedField(string name, Cci.INamedTypeDefinition containingType, Cci.I
     /// </summary>
     internal abstract class DefaultTypeDef : Cci.ITypeDefinition
     {
-        public IEnumerable<Cci.IEventDefinition> Events
+        public IEnumerable<Cci.IEventDefinition> GetEvents(EmitContext context)
             => SpecializedCollections.EmptyEnumerable<Cci.IEventDefinition>();
 
         public IEnumerable<Cci.MethodImplementation> GetExplicitImplementationOverrides(EmitContext context)
diff --git a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
index 051f8e3c5b693..ad2bd964a5862 100644
--- a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
+++ b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
@@ -659,6 +659,8 @@ internal int RunCore(TextWriter consoleOutput, ErrorLogger errorLogger, Cancella
                             success = compilation.CompileMethods(
                                 moduleBeingBuilt,
                                 Arguments.EmitPdb,
+                                emitOptions.EmitMetadataOnly,
+                                emitOptions.EmitTestCoverageData,
                                 diagnosticBag,
                                 filterOpt: null,
                                 cancellationToken: cancellationToken);
@@ -704,6 +706,7 @@ internal int RunCore(TextWriter consoleOutput, ErrorLogger errorLogger, Cancella
                                             moduleBeingBuilt,
                                             xmlStreamDisposerOpt?.Stream,
                                             win32ResourceStreamOpt,
+                                            emitOptions.OutputNameOverride,
                                             diagnosticBag,
                                             cancellationToken);
                                     }
@@ -761,6 +764,9 @@ internal int RunCore(TextWriter consoleOutput, ErrorLogger errorLogger, Cancella
                                     testSymWriterFactory: null,
                                     diagnostics: diagnosticBag,
                                     metadataOnly: emitOptions.EmitMetadataOnly,
+                                    includePrivateMembers: emitOptions.IncludePrivateMembers,
+                                    emitTestCoverageData: emitOptions.EmitTestCoverageData,
+                                    pdbFilePath: emitOptions.PdbFilePath,
                                     cancellationToken: cancellationToken);
                             }
                             finally
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index daf5c278c980c..a550001f4e3d2 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -1739,6 +1739,8 @@ internal abstract CommonPEModuleBuilder CreateModuleBuilder(
         internal abstract bool CompileMethods(
             CommonPEModuleBuilder moduleBuilder,
             bool emittingPdb,
+            bool emitMetadataOnly,
+            bool emitTestCoverageData,
             DiagnosticBag diagnostics,
             Predicate<ISymbol> filterOpt,
             CancellationToken cancellationToken);
@@ -1830,6 +1832,7 @@ internal abstract bool GenerateResourcesAndDocumentationComments(
             CommonPEModuleBuilder moduleBeingBuilt,
             Stream xmlDocumentationStream,
             Stream win32ResourcesStream,
+            string outputNameOverride,
             DiagnosticBag diagnostics,
             CancellationToken cancellationToken);
 
@@ -1864,9 +1867,11 @@ internal bool Compile(
                 return CompileMethods(
                     moduleBuilder,
                     emittingPdb,
-                    diagnostics,
-                    filterOpt,
-                    cancellationToken);
+                    emitMetadataOnly: false,
+                    emitTestCoverageData: false,
+                    diagnostics: diagnostics,
+                    filterOpt: filterOpt,
+                    cancellationToken: cancellationToken);
             }
             finally
             {
@@ -2072,6 +2077,11 @@ public EmitResult Emit(
                 throw new ArgumentException(CodeAnalysisResources.MetadataPeStreamUnexpectedWhenEmittingMetadataOnly, nameof(metadataPEStream));
             }
 
+            if (metadataPEStream != null && options?.IncludePrivateMembers == true)
+            {
+                throw new ArgumentException(CodeAnalysisResources.IncludingPrivateMembersUnexpectedWhenEmittingToMetadataPeStream, nameof(metadataPEStream));
+            }
+
             if (options?.DebugInformationFormat == DebugInformationFormat.Embedded &&
                 options?.EmitMetadataOnly == true)
             {
@@ -2156,8 +2166,10 @@ internal EmitResult Emit(
             CompilationTestData testData,
             CancellationToken cancellationToken)
         {
-            bool embedPdb = options?.DebugInformationFormat == DebugInformationFormat.Embedded;
+            options = options ?? EmitOptions.Default.WithIncludePrivateMembers(metadataPEStream == null);
+            bool embedPdb = options.DebugInformationFormat == DebugInformationFormat.Embedded;
             Debug.Assert(!embedPdb || pdbStream == null);
+            Debug.Assert(metadataPEStream == null || !options.IncludePrivateMembers); // you may not use a secondary stream and include private members together
 
             var diagnostics = DiagnosticBag.GetInstance();
 
@@ -2180,16 +2192,19 @@ internal EmitResult Emit(
                     success = CompileMethods(
                         moduleBeingBuilt,
                         emittingPdb: pdbStream != null || embedPdb,
+                        emitMetadataOnly: options.EmitMetadataOnly,
+                        emitTestCoverageData: options.EmitTestCoverageData,
                         diagnostics: diagnostics,
                         filterOpt: null,
                         cancellationToken: cancellationToken);
 
-                    if (!moduleBeingBuilt.EmitOptions.EmitMetadataOnly)
+                    if (!options.EmitMetadataOnly)
                     {
                         if (!GenerateResourcesAndDocumentationComments(
                             moduleBeingBuilt,
                             xmlDocumentationStream,
                             win32Resources,
+                            options.OutputNameOverride,
                             diagnostics,
                             cancellationToken))
                         {
@@ -2216,7 +2231,10 @@ internal EmitResult Emit(
                         (pdbStream != null) ? new SimpleEmitStreamProvider(pdbStream) : null,
                         testData?.SymWriterFactory,
                         diagnostics,
-                        metadataOnly: (options != null) && options.EmitMetadataOnly,
+                        metadataOnly: options.EmitMetadataOnly,
+                        includePrivateMembers: options.IncludePrivateMembers,
+                        emitTestCoverageData: options.EmitTestCoverageData,
+                        pdbFilePath: options.PdbFilePath,
                         cancellationToken: cancellationToken);
                 }
             }
@@ -2321,14 +2339,7 @@ internal CommonPEModuleBuilder CheckOptionsAndCreateModuleBuilder(
             CompilationTestData testData,
             CancellationToken cancellationToken)
         {
-            if (options != null)
-            {
-                options.ValidateOptions(diagnostics, this.MessageProvider);
-            }
-            else
-            {
-                options = EmitOptions.Default;
-            }
+            options.ValidateOptions(diagnostics, this.MessageProvider);
 
             if (debugEntryPoint != null)
             {
@@ -2384,6 +2395,9 @@ internal bool SerializeToPeStream(
             Func<object> testSymWriterFactory,
             DiagnosticBag diagnostics,
             bool metadataOnly,
+            bool includePrivateMembers,
+            bool emitTestCoverageData,
+            string pdbFilePath,
             CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -2397,13 +2411,12 @@ internal bool SerializeToPeStream(
             Stream portablePdbStream = null;
 
             bool deterministic = IsEmitDeterministic;
-            var debugFormat = moduleBeingBuilt.EmitOptions.DebugInformationFormat;
 
             // PDB Stream provider should not be given if PDB is to be embedded into the PE file:
-            Debug.Assert(debugFormat != DebugInformationFormat.Embedded || pdbStreamProvider == null);
+            Debug.Assert(moduleBeingBuilt.DebugInformationFormat != DebugInformationFormat.Embedded || pdbStreamProvider == null);
 
-            string pdbPath = (pdbStreamProvider != null || debugFormat == DebugInformationFormat.Embedded) ? 
-                (moduleBeingBuilt.EmitOptions.PdbFilePath ?? FileNameUtilities.ChangeExtension(SourceModule.Name, "pdb")) : null;
+            string pdbPath = (pdbStreamProvider != null || moduleBeingBuilt.DebugInformationFormat == DebugInformationFormat.Embedded) ?
+                (pdbFilePath ?? FileNameUtilities.ChangeExtension(SourceModule.Name, "pdb")) : null;
 
             // The PDB path is emitted in it's entirety into the PE.  This makes it impossible to have deterministic
             // builds that occur in different source directories.  To enable this we shave all path information from
@@ -2413,7 +2426,7 @@ internal bool SerializeToPeStream(
             // tracks getting an official solution here.
             //
             // https://github.com/dotnet/roslyn/issues/9813
-            string pePdbPath = (debugFormat == DebugInformationFormat.Embedded || Feature("pdb-path-determinism") != null) && !string.IsNullOrEmpty(pdbPath)
+            string pePdbPath = (moduleBeingBuilt.DebugInformationFormat == DebugInformationFormat.Embedded || Feature("pdb-path-determinism") != null) && !string.IsNullOrEmpty(pdbPath)
                 ? Path.GetFileName(pdbPath)
                 : pdbPath;
 
@@ -2421,7 +2434,7 @@ internal bool SerializeToPeStream(
             {
                 metadataDiagnostics = DiagnosticBag.GetInstance();
 
-                if (debugFormat == DebugInformationFormat.Pdb && pdbStreamProvider != null)
+                if (moduleBeingBuilt.DebugInformationFormat == DebugInformationFormat.Pdb && pdbStreamProvider != null)
                 {
                     // The calls ISymUnmanagedWriter2.GetDebugInfo require a file name in order to succeed.  This is 
                     // frequently used during PDB writing.  Ensure a name is provided here in the case we were given
@@ -2430,7 +2443,7 @@ internal bool SerializeToPeStream(
                 }
 
                 Func<Stream> getPortablePdbStream;
-                if (debugFormat == DebugInformationFormat.PortablePdb && pdbStreamProvider != null)
+                if (moduleBeingBuilt.DebugInformationFormat == DebugInformationFormat.PortablePdb && pdbStreamProvider != null)
                 {
                     getPortablePdbStream = () =>
                     {
@@ -2515,7 +2528,8 @@ internal bool SerializeToPeStream(
                 try
                 {
                     if (SerializePeToStream(
-                        new EmitContext(moduleBeingBuilt, null, metadataDiagnostics),
+                        moduleBeingBuilt,
+                        metadataDiagnostics,
                         this.MessageProvider,
                         getPeStream,
                         getRefPeStream,
@@ -2523,7 +2537,9 @@ internal bool SerializeToPeStream(
                         nativePdbWriter,
                         pePdbPath,
                         metadataOnly,
+                        includePrivateMembers,
                         deterministic,
+                        emitTestCoverageData,
                         cancellationToken))
                     {
                         if (nativePdbWriter != null)
@@ -2598,19 +2614,25 @@ internal bool SerializeToPeStream(
         }
 
         internal static bool SerializePeToStream(
-             EmitContext context,
-             CommonMessageProvider messageProvider,
-             Func<Stream> getPeStream,
-             Func<Stream> getMetadataPeStreamOpt,
-             Func<Stream> getPortablePdbStreamOpt,
-             Cci.PdbWriter nativePdbWriterOpt,
-             string pdbPathOpt,
-             bool metadataOnly,
-             bool isDeterministic,
-             CancellationToken cancellationToken)
+            CommonPEModuleBuilder moduleBeingBuilt,
+            DiagnosticBag metadataDiagnostics,
+            CommonMessageProvider messageProvider,
+            Func<Stream> getPeStream,
+            Func<Stream> getMetadataPeStreamOpt,
+            Func<Stream> getPortablePdbStreamOpt,
+            Cci.PdbWriter nativePdbWriterOpt,
+            string pdbPathOpt,
+            bool metadataOnly,
+            bool includePrivateMembers,
+            bool isDeterministic,
+            bool emitTestCoverageData,
+            CancellationToken cancellationToken)
         {
+            bool emitSecondaryAssembly = getMetadataPeStreamOpt != null;
+
+            bool includePrivateMembersOnPrimaryOutput = metadataOnly ? includePrivateMembers : true;
             if (!Cci.PeWriter.WritePeToStream(
-                context,
+                new EmitContext(moduleBeingBuilt, null, metadataDiagnostics, metadataOnly, includePrivateMembersOnPrimaryOutput),
                 messageProvider,
                 getPeStream,
                 getPortablePdbStreamOpt,
@@ -2618,18 +2640,20 @@ internal static bool SerializePeToStream(
                 pdbPathOpt,
                 metadataOnly,
                 isDeterministic,
+                emitTestCoverageData,
                 cancellationToken))
             {
                 return false;
             }
 
             // produce the secondary output (ref assembly) if needed
-            if (getMetadataPeStreamOpt != null)
+            if (emitSecondaryAssembly)
             {
                 Debug.Assert(!metadataOnly);
+                Debug.Assert(!includePrivateMembers);
 
                 if (!Cci.PeWriter.WritePeToStream(
-                    context,
+                    new EmitContext(moduleBeingBuilt, null, metadataDiagnostics, metadataOnly: true, includePrivateMembers: false),
                     messageProvider,
                     getMetadataPeStreamOpt,
                     getPortablePdbStreamOpt: null,
@@ -2637,6 +2661,7 @@ internal static bool SerializePeToStream(
                     pdbPathOpt: null,
                     metadataOnly: true,
                     isDeterministic: isDeterministic,
+                    emitTestCoverageData: false,
                     cancellationToken: cancellationToken))
                 {
                     return false;
@@ -2657,17 +2682,18 @@ internal EmitBaseline SerializeToDeltaStreams(
             ICollection<MethodDefinitionHandle> updatedMethods,
             DiagnosticBag diagnostics,
             Func<object> testSymWriterFactory,
+            string pdbFilePath,
             CancellationToken cancellationToken)
         {
-            var nativePdbWriterOpt = (moduleBeingBuilt.EmitOptions.DebugInformationFormat != DebugInformationFormat.Pdb) ? null :
+            var nativePdbWriterOpt = (moduleBeingBuilt.DebugInformationFormat != DebugInformationFormat.Pdb) ? null :
                 new Cci.PdbWriter(
-                    moduleBeingBuilt.EmitOptions.PdbFilePath ?? FileNameUtilities.ChangeExtension(SourceModule.Name, "pdb"),
+                    pdbFilePath ?? FileNameUtilities.ChangeExtension(SourceModule.Name, "pdb"),
                     testSymWriterFactory,
                     deterministic: false);
 
             using (nativePdbWriterOpt)
             {
-                var context = new EmitContext(moduleBeingBuilt, null, diagnostics);
+                var context = new EmitContext(moduleBeingBuilt, null, diagnostics, metadataOnly: false, includePrivateMembers: true);
                 var encId = Guid.NewGuid();
 
                 try
diff --git a/src/Compilers/Core/Portable/Emit/CommonPEModuleBuilder.cs b/src/Compilers/Core/Portable/Emit/CommonPEModuleBuilder.cs
index cb1bc5c85f79a..bdf7c957645d5 100644
--- a/src/Compilers/Core/Portable/Emit/CommonPEModuleBuilder.cs
+++ b/src/Compilers/Core/Portable/Emit/CommonPEModuleBuilder.cs
@@ -19,7 +19,6 @@ internal abstract class CommonPEModuleBuilder : Cci.IUnit, Cci.IModuleReference
     {
         internal readonly DebugDocumentsBuilder DebugDocumentsBuilder;
         internal readonly IEnumerable<ResourceDescription> ManifestResources;
-        internal readonly EmitOptions EmitOptions;
         internal readonly Cci.ModulePropertiesForSerialization SerializationProperties;
         internal readonly OutputKind OutputKind;
         internal IEnumerable<Cci.IWin32Resource> Win32Resources;
@@ -41,6 +40,8 @@ internal abstract class CommonPEModuleBuilder : Cci.IUnit, Cci.IModuleReference
         // Only set when running tests to allow realized IL for a given method to be looked up by method.
         internal ConcurrentDictionary<IMethodSymbol, CompilationTestData.MethodData> TestData { get; private set; }
 
+        internal readonly DebugInformationFormat DebugInformationFormat;
+
         public CommonPEModuleBuilder(
             IEnumerable<ResourceDescription> manifestResources,
             EmitOptions emitOptions,
@@ -49,16 +50,15 @@ public CommonPEModuleBuilder(
             Compilation compilation)
         {
             Debug.Assert(manifestResources != null);
-            Debug.Assert(emitOptions != null);
             Debug.Assert(serializationProperties != null);
             Debug.Assert(compilation != null);
 
-            EmitOptions = emitOptions;
             ManifestResources = manifestResources;
             DebugDocumentsBuilder = new DebugDocumentsBuilder(compilation.Options.SourceReferenceResolver, compilation.IsCaseSensitive);
             OutputKind = outputKind;
             SerializationProperties = serializationProperties;
             _methodBodyMap = new ConcurrentDictionary<IMethodSymbol, Cci.IMethodBody>(ReferenceEqualityComparer.Instance);
+            DebugInformationFormat = emitOptions.DebugInformationFormat;
         }
 
         /// <summary>
@@ -80,7 +80,7 @@ public CommonPEModuleBuilder(
         internal abstract Cci.ITypeReference Translate(ITypeSymbol symbol, SyntaxNode syntaxOpt, DiagnosticBag diagnostics);
         internal abstract Cci.IMethodReference Translate(IMethodSymbol symbol, DiagnosticBag diagnostics, bool needDeclaration);
         internal abstract bool SupportsPrivateImplClass { get; }
-        internal abstract ImmutableArray<Cci.INamespaceTypeDefinition> GetAnonymousTypes();
+        internal abstract ImmutableArray<Cci.INamespaceTypeDefinition> GetAnonymousTypes(EmitContext context);
         internal abstract Compilation CommonCompilation { get; }
         internal abstract IModuleSymbol CommonSourceModule { get; }
         internal abstract IAssemblySymbol CommonCorLibrary { get; }
@@ -89,7 +89,7 @@ public CommonPEModuleBuilder(
         internal abstract ImmutableDictionary<Cci.ITypeDefinition, ImmutableArray<Cci.ITypeDefinitionMember>> GetSynthesizedMembers();
         internal abstract CommonEmbeddedTypesManager CommonEmbeddedTypesManagerOpt { get; }
         internal abstract Cci.ITypeReference EncTranslateType(ITypeSymbol type, DiagnosticBag diagnostics);
-        public abstract IEnumerable<Cci.ICustomAttribute> GetSourceAssemblyAttributes();
+        public abstract IEnumerable<Cci.ICustomAttribute> GetSourceAssemblyAttributes(bool isRefAssembly);
         public abstract IEnumerable<Cci.SecurityAttribute> GetSourceAssemblySecurityAttributes();
         public abstract IEnumerable<Cci.ICustomAttribute> GetSourceModuleAttributes();
         internal abstract Cci.ICustomAttribute SynthesizeAttribute(WellKnownMember attributeConstructor);
@@ -247,7 +247,7 @@ public uint GetFakeSymbolTokenForIL(Cci.IReference symbol, SyntaxNode syntaxNode
             uint token = _referencesInILMap.GetOrAddTokenFor(symbol, out added);
             if (added)
             {
-                ReferenceDependencyWalker.VisitReference(symbol, new EmitContext(this, syntaxNode, diagnostics));
+                ReferenceDependencyWalker.VisitReference(symbol, new EmitContext(this, syntaxNode, diagnostics, metadataOnly: false, includePrivateMembers: true)); // PROTOTYPE(refout) Not sure about this
             }
             return token;
         }
@@ -499,7 +499,7 @@ protected bool ContainsTopLevelType(string fullEmittedName)
             VisitTopLevelType(noPiaIndexer, _rootModuleType);
             yield return _rootModuleType;
 
-            foreach (var type in this.GetAnonymousTypes())
+            foreach (var type in this.GetAnonymousTypes(context))
             {
                 AddTopLevelType(names, type);
                 VisitTopLevelType(noPiaIndexer, type);
diff --git a/src/Compilers/Core/Portable/Emit/Context.cs b/src/Compilers/Core/Portable/Emit/Context.cs
index 494c8ddb48ed5..9d608ff6bdf49 100644
--- a/src/Compilers/Core/Portable/Emit/Context.cs
+++ b/src/Compilers/Core/Portable/Emit/Context.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Diagnostics;
 
 namespace Microsoft.CodeAnalysis.Emit
@@ -9,15 +10,40 @@ internal struct EmitContext
         public readonly CommonPEModuleBuilder Module;
         public readonly SyntaxNode SyntaxNodeOpt;
         public readonly DiagnosticBag Diagnostics;
+        private readonly Flags _flags;
 
-        public EmitContext(CommonPEModuleBuilder module, SyntaxNode syntaxNodeOpt, DiagnosticBag diagnostics)
+        public bool IncludePrivateMembers => (_flags & Flags.IncludePrivateMembers) != 0;
+        public bool MetadataOnly => (_flags & Flags.MetadataOnly) != 0;
+        public bool IsRefAssembly => MetadataOnly && !IncludePrivateMembers;
+
+        public EmitContext(CommonPEModuleBuilder module, SyntaxNode syntaxNodeOpt, DiagnosticBag diagnostics, bool metadataOnly, bool includePrivateMembers)
         {
             Debug.Assert(module != null);
             Debug.Assert(diagnostics != null);
+            Debug.Assert(includePrivateMembers || metadataOnly);
 
             Module = module;
             SyntaxNodeOpt = syntaxNodeOpt;
             Diagnostics = diagnostics;
+
+            Flags flags = Flags.None;
+            if (metadataOnly)
+            {
+                flags |= Flags.MetadataOnly;
+            }
+            if (includePrivateMembers)
+            {
+                flags |= Flags.IncludePrivateMembers;
+            }
+            _flags = flags;
+        }
+
+        [Flags]
+        private enum Flags
+        {
+            None = 0,
+            MetadataOnly = 1,
+            IncludePrivateMembers = 2,
         }
     }
 }
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
index 7c8b2fdb0ec67..360cef3af8267 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
@@ -50,19 +50,20 @@ public DeltaMetadataWriter(
             DefinitionMap definitionMap,
             SymbolChanges changes,
             CancellationToken cancellationToken)
-            : base(metadata: MakeTablesBuilder(previousGeneration), 
-                   debugMetadataOpt: (context.Module.EmitOptions.DebugInformationFormat == DebugInformationFormat.PortablePdb) ? new MetadataBuilder() : null, 
+            : base(metadata: MakeTablesBuilder(previousGeneration),
+                   debugMetadataOpt: (context.Module.DebugInformationFormat == DebugInformationFormat.PortablePdb) ? new MetadataBuilder() : null,
                    dynamicAnalysisDataWriterOpt: null,
                    context: context,
                    messageProvider: messageProvider,
-                   metadataOnly: false, 
+                   metadataOnly: false,
                    deterministic: false,
+                   emitTestCoverageData: false,
                    cancellationToken: cancellationToken)
         {
             Debug.Assert(previousGeneration != null);
             Debug.Assert(encId != default(Guid));
             Debug.Assert(encId != previousGeneration.EncId);
-            Debug.Assert(context.Module.EmitOptions.DebugInformationFormat != DebugInformationFormat.Embedded);
+            Debug.Assert(context.Module.DebugInformationFormat != DebugInformationFormat.Embedded);
 
             _previousGeneration = previousGeneration;
             _encId = encId;
@@ -486,7 +487,7 @@ protected override void CreateIndicesForNonTypeMembers(ITypeDefinition typeDef)
             var ok = _typeDefs.TryGetValue(typeDef, out typeIndex);
             Debug.Assert(ok);
 
-            foreach (var eventDef in typeDef.Events)
+            foreach (var eventDef in typeDef.GetEvents(this.Context))
             {
                 int eventMapIndex;
                 if (!_eventMap.TryGetValue(typeIndex, out eventMapIndex))
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolChanges.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolChanges.cs
index 1cbacb1b0cb9f..4e43a6e9abb77 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolChanges.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolChanges.cs
@@ -188,7 +188,7 @@ private SymbolChange GetChange(ISymbol symbol)
         public IEnumerable<INamespaceTypeDefinition> GetTopLevelTypes(EmitContext context)
         {
             var module = (CommonPEModuleBuilder)context.Module;
-            foreach (var type in module.GetAnonymousTypes())
+            foreach (var type in module.GetAnonymousTypes(context))
             {
                 yield return type;
             }
diff --git a/src/Compilers/Core/Portable/Emit/EmitOptions.cs b/src/Compilers/Core/Portable/Emit/EmitOptions.cs
index 4b64674b709b6..28d1a900b011b 100644
--- a/src/Compilers/Core/Portable/Emit/EmitOptions.cs
+++ b/src/Compilers/Core/Portable/Emit/EmitOptions.cs
@@ -26,11 +26,9 @@ public sealed class EmitOptions : IEquatable<EmitOptions>
 
         /// <summary>
         /// Unless set (private) members that don't affect the language semantics of the resulting assembly will be excluded
-        /// when emitting with <see cref="EmitMetadataOnly"/> on. 
+        /// when emitting metadata-only assemblies as primary output (with <see cref="EmitMetadataOnly"/> on).
+        /// If emitting a secondary output, this flag is required to be false.
         /// </summary>
-        /// <remarks>
-        /// Has no effect when <see cref="EmitMetadataOnly"/> is false.
-        /// </remarks>
         public bool IncludePrivateMembers { get; private set; }
 
         /// <summary>
@@ -133,7 +131,7 @@ public EmitOptions(
             SubsystemVersion subsystemVersion = default(SubsystemVersion),
             string runtimeMetadataVersion = null,
             bool tolerateErrors = false,
-            bool includePrivateMembers = false,
+            bool includePrivateMembers = true,
             ImmutableArray<InstrumentationKind> instrumentationKinds = default(ImmutableArray<InstrumentationKind>))
         {
             this.EmitMetadataOnly = metadataOnly;
diff --git a/src/Compilers/Core/Portable/Emit/NoPia/CommonEmbeddedType.cs b/src/Compilers/Core/Portable/Emit/NoPia/CommonEmbeddedType.cs
index 0b93a04a61711..704346c9a7d64 100644
--- a/src/Compilers/Core/Portable/Emit/NoPia/CommonEmbeddedType.cs
+++ b/src/Compilers/Core/Portable/Emit/NoPia/CommonEmbeddedType.cs
@@ -232,31 +232,28 @@ Cci.ITypeReference Cci.ITypeDefinition.GetBaseClass(EmitContext context)
                 return GetBaseClass((TPEModuleBuilder)context.Module, (TSyntaxNode)context.SyntaxNodeOpt, context.Diagnostics);
             }
 
-            IEnumerable<Cci.IEventDefinition> Cci.ITypeDefinition.Events
+            IEnumerable<Cci.IEventDefinition> Cci.ITypeDefinition.GetEvents(EmitContext context)
             {
-                get
+                if (_lazyEvents.IsDefault)
                 {
-                    if (_lazyEvents.IsDefault)
-                    {
-                        Debug.Assert(TypeManager.IsFrozen);
+                    Debug.Assert(TypeManager.IsFrozen);
 
-                        var builder = ArrayBuilder<Cci.IEventDefinition>.GetInstance();
+                    var builder = ArrayBuilder<Cci.IEventDefinition>.GetInstance();
 
-                        foreach (var e in GetEventsToEmit())
-                        {
-                            TEmbeddedEvent embedded;
+                    foreach (var e in GetEventsToEmit())
+                    {
+                        TEmbeddedEvent embedded;
 
-                            if (TypeManager.EmbeddedEventsMap.TryGetValue(e, out embedded))
-                            {
-                                builder.Add(embedded);
-                            }
+                        if (TypeManager.EmbeddedEventsMap.TryGetValue(e, out embedded))
+                        {
+                            builder.Add(embedded);
                         }
-
-                        ImmutableInterlocked.InterlockedInitialize(ref _lazyEvents, builder.ToImmutableAndFree());
                     }
 
-                    return _lazyEvents;
+                    ImmutableInterlocked.InterlockedInitialize(ref _lazyEvents, builder.ToImmutableAndFree());
                 }
+
+                return _lazyEvents;
             }
 
             IEnumerable<Cci.MethodImplementation> Cci.ITypeDefinition.GetExplicitImplementationOverrides(EmitContext context)
diff --git a/src/Compilers/Core/Portable/Emit/NoPia/EmbeddedTypesManager.cs b/src/Compilers/Core/Portable/Emit/NoPia/EmbeddedTypesManager.cs
index 3dcaa30aaee8e..f7f45f8f87ffd 100644
--- a/src/Compilers/Core/Portable/Emit/NoPia/EmbeddedTypesManager.cs
+++ b/src/Compilers/Core/Portable/Emit/NoPia/EmbeddedTypesManager.cs
@@ -189,7 +189,7 @@ public int Compare(TEmbeddedType x, TEmbeddedType y)
 
         protected void EmbedReferences(Cci.ITypeDefinitionMember embeddedMember, TSyntaxNode syntaxNodeOpt, DiagnosticBag diagnostics)
         {
-            var noPiaIndexer = new Cci.NoPiaReferenceIndexer(new EmitContext(ModuleBeingBuilt, syntaxNodeOpt, diagnostics));
+            var noPiaIndexer = new Cci.NoPiaReferenceIndexer(new EmitContext(ModuleBeingBuilt, syntaxNodeOpt, diagnostics, metadataOnly: false, includePrivateMembers: true));
             noPiaIndexer.Visit(embeddedMember);
         }
 
diff --git a/src/Compilers/Core/Portable/PEWriter/FullMetadataWriter.cs b/src/Compilers/Core/Portable/PEWriter/FullMetadataWriter.cs
index 11cfb2027b637..4ceb1ad3c7f29 100644
--- a/src/Compilers/Core/Portable/PEWriter/FullMetadataWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/FullMetadataWriter.cs
@@ -39,12 +39,13 @@ public static MetadataWriter Create(
             CommonMessageProvider messageProvider,
             bool metadataOnly,
             bool deterministic,
+            bool emitTestCoverageData,
             bool hasPdbStream,
             CancellationToken cancellationToken)
         {
             var builder = new MetadataBuilder();
             MetadataBuilder debugBuilderOpt;
-            switch (context.Module.EmitOptions.DebugInformationFormat)
+            switch (context.Module.DebugInformationFormat)
             {
                 case DebugInformationFormat.PortablePdb:
                     debugBuilderOpt = hasPdbStream ? new MetadataBuilder() : null;
@@ -59,11 +60,12 @@ public static MetadataWriter Create(
                     break;
             }
 
-            var dynamicAnalysisDataWriterOpt = context.Module.EmitOptions.EmitTestCoverageData ? 
-                new DynamicAnalysisDataWriter(context.Module.DebugDocumentCount, context.Module.HintNumberOfMethodDefinitions) : 
+            var dynamicAnalysisDataWriterOpt = emitTestCoverageData ?
+                new DynamicAnalysisDataWriter(context.Module.DebugDocumentCount, context.Module.HintNumberOfMethodDefinitions) :
                 null;
 
-            return new FullMetadataWriter(context, builder, debugBuilderOpt, dynamicAnalysisDataWriterOpt, messageProvider, metadataOnly, deterministic, cancellationToken);
+            return new FullMetadataWriter(context, builder, debugBuilderOpt, dynamicAnalysisDataWriterOpt, messageProvider, metadataOnly, deterministic,
+                emitTestCoverageData, cancellationToken);
         }
 
         private FullMetadataWriter(
@@ -74,8 +76,10 @@ private FullMetadataWriter(
             CommonMessageProvider messageProvider,
             bool metadataOnly,
             bool deterministic,
+            bool emitTestCoverageData,
             CancellationToken cancellationToken)
-            : base(builder, debugBuilderOpt, dynamicAnalysisDataWriterOpt, context, messageProvider, metadataOnly, deterministic, cancellationToken)
+            : base(builder, debugBuilderOpt, dynamicAnalysisDataWriterOpt, context, messageProvider, metadataOnly, deterministic,
+                  emitTestCoverageData, cancellationToken)
         {
             // EDMAURER make some intelligent guesses for the initial sizes of these things.
             int numMethods = this.module.HintNumberOfMethodDefinitions;
@@ -390,7 +394,7 @@ protected override void CreateIndicesForNonTypeMembers(ITypeDefinition typeDef)
                 this.methodImplList.Add(methodImplementation);
             }
 
-            foreach (IEventDefinition eventDef in typeDef.Events)
+            foreach (IEventDefinition eventDef in typeDef.GetEvents(Context))
             {
                 _eventDefs.Add(eventDef);
             }
diff --git a/src/Compilers/Core/Portable/PEWriter/Members.cs b/src/Compilers/Core/Portable/PEWriter/Members.cs
index 8dd6fcb535b50..4c0ffc23e73b7 100644
--- a/src/Compilers/Core/Portable/PEWriter/Members.cs
+++ b/src/Compilers/Core/Portable/PEWriter/Members.cs
@@ -979,5 +979,27 @@ internal static bool HasBody(this IMethodDefinition methodDef)
             return !methodDef.IsAbstract && !methodDef.IsExternal &&
                 (methodDef.ContainingTypeDefinition == null || !methodDef.ContainingTypeDefinition.IsComObject);
         }
+
+        /// <summary>
+        /// When emitting ref assemblies, some members will not be included.
+        /// </summary>
+        public static bool ShouldInclude(this ITypeDefinitionMember member, EmitContext context)
+        {
+            var method = member as IMethodDefinition;
+            if (method != null && method.IsVirtual)
+            {
+                return true;
+            }
+
+            switch (member.Visibility)
+            {
+                case TypeMemberVisibility.Private:
+                    return context.IncludePrivateMembers;
+                case TypeMemberVisibility.Assembly:
+                case TypeMemberVisibility.FamilyAndAssembly:
+                    return context.IncludePrivateMembers || context.Module.SourceAssemblyOpt?.InternalsAreVisible == true;
+            }
+            return true;
+        }
     }
 }
diff --git a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
index aeeb574e8dc7b..930a5c7d8cdec 100644
--- a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
@@ -66,6 +66,7 @@ internal abstract partial class MetadataWriter
         private readonly bool _deterministic;
 
         internal readonly bool MetadataOnly;
+        internal readonly bool EmitTestCoverageData;
 
         // A map of method body before token translation to RVA. Used for deduplication of small bodies.
         private readonly Dictionary<ImmutableArray<byte>, int> _smallMethodBodies;
@@ -86,11 +87,13 @@ protected MetadataWriter(
             CommonMessageProvider messageProvider,
             bool metadataOnly,
             bool deterministic,
+            bool emitTestCoverageData,
             CancellationToken cancellationToken)
         {
             this.module = context.Module;
             _deterministic = deterministic;
             this.MetadataOnly = metadataOnly;
+            this.EmitTestCoverageData = emitTestCoverageData;
 
             // EDMAURER provide some reasonable size estimates for these that will avoid
             // much of the reallocation that would occur when growing these from empty.
@@ -506,7 +509,7 @@ private void CreateUserStringIndices()
 
         private void CreateIndicesForModule()
         {
-            var nestedTypes = new Queue<ITypeDefinition>();
+            var nestedTypes = new Queue<INestedTypeDefinition>();
 
             foreach (INamespaceTypeDefinition typeDef in this.GetTopLevelTypes(this.module))
             {
@@ -515,7 +518,8 @@ private void CreateIndicesForModule()
 
             while (nestedTypes.Count > 0)
             {
-                this.CreateIndicesFor(nestedTypes.Dequeue(), nestedTypes);
+                var nestedType = nestedTypes.Dequeue();
+                this.CreateIndicesFor(nestedType, nestedTypes);
             }
         }
 
@@ -523,7 +527,7 @@ protected virtual void OnIndicesCreated()
         {
         }
 
-        private void CreateIndicesFor(ITypeDefinition typeDef, Queue<ITypeDefinition> nestedTypes)
+        private void CreateIndicesFor(ITypeDefinition typeDef, Queue<INestedTypeDefinition> nestedTypes)
         {
             _cancellationToken.ThrowIfCancellationRequested();
 
@@ -1790,9 +1794,16 @@ public void BuildMetadataAndIL(
                 }
             }
 
-            int[] methodBodyOffsets = MetadataOnly ?
-                SerializeThrowNullMethodBodies(ilBuilder, out mvidStringFixup) :
-                SerializeMethodBodies(ilBuilder, nativePdbWriterOpt, out mvidStringFixup);
+            int[] methodBodyOffsets;
+            if (MetadataOnly)
+            {
+                methodBodyOffsets = SerializeThrowNullMethodBodies(ilBuilder);
+                mvidStringFixup = default(Blob);
+            }
+            else
+            {
+                methodBodyOffsets = SerializeMethodBodies(ilBuilder, nativePdbWriterOpt, out mvidStringFixup);
+            }
 
             _cancellationToken.ThrowIfCancellationRequested();
 
@@ -2011,7 +2022,7 @@ private void AddAssemblyAttributesToTable()
             }
 
             AddAssemblyAttributesToTable(
-                this.module.GetSourceAssemblyAttributes(),
+                this.module.GetSourceAssemblyAttributes(Context.IsRefAssembly),
                 needsDummyParent: writingNetModule,
                 isSecurity: false);
         }
@@ -2815,8 +2826,9 @@ private void PopulateStandaloneSignatures()
             }
         }
 
-        private int[] SerializeThrowNullMethodBodies(BlobBuilder ilBuilder, out Blob mvidStringFixup)
+        private int[] SerializeThrowNullMethodBodies(BlobBuilder ilBuilder)
         {
+            Debug.Assert(MetadataOnly);
             var methods = this.GetMethodDefs();
             int[] bodyOffsets = new int[methods.Count];
 
@@ -2840,7 +2852,6 @@ private int[] SerializeThrowNullMethodBodies(BlobBuilder ilBuilder, out Blob mvi
                 methodRid++;
             }
 
-            mvidStringFixup = default(Blob);
             return bodyOffsets;
         }
 
diff --git a/src/Compilers/Core/Portable/PEWriter/NoPiaReferenceIndexer.cs b/src/Compilers/Core/Portable/PEWriter/NoPiaReferenceIndexer.cs
index 22fadb61bf7f3..a740dc8c29c33 100644
--- a/src/Compilers/Core/Portable/PEWriter/NoPiaReferenceIndexer.cs
+++ b/src/Compilers/Core/Portable/PEWriter/NoPiaReferenceIndexer.cs
@@ -23,7 +23,7 @@ public override void Visit(CommonPEModuleBuilder module)
             //EDMAURER visit these assembly-level attributes even when producing a module.
             //They'll be attached off the "AssemblyAttributesGoHere" typeRef if a module is being produced.
 
-            this.Visit(module.GetSourceAssemblyAttributes());
+            this.Visit(module.GetSourceAssemblyAttributes(Context.IsRefAssembly));
             this.Visit(module.GetSourceAssemblySecurityAttributes());
             this.Visit(module.GetSourceModuleAttributes());
         }
diff --git a/src/Compilers/Core/Portable/PEWriter/PeWriter.cs b/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
index 82fecdd4e60c6..cd9011bb617ab 100644
--- a/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
@@ -35,12 +35,14 @@ internal static bool WritePeToStream(
             string pdbPathOpt,
             bool metadataOnly,
             bool isDeterministic,
+            bool emitTestCoverageData,
             CancellationToken cancellationToken)
         {
             // If PDB writer is given, we have to have PDB path.
             Debug.Assert(nativePdbWriterOpt == null || pdbPathOpt != null);
 
-            var mdWriter = FullMetadataWriter.Create(context, messageProvider, metadataOnly, isDeterministic, getPortablePdbStreamOpt != null, cancellationToken);
+            var mdWriter = FullMetadataWriter.Create(context, messageProvider, metadataOnly, isDeterministic,
+                emitTestCoverageData, getPortablePdbStreamOpt != null, cancellationToken);
 
             var properties = context.Module.SerializationProperties;
 
diff --git a/src/Compilers/Core/Portable/PEWriter/ReferenceIndexer.cs b/src/Compilers/Core/Portable/PEWriter/ReferenceIndexer.cs
index b871a1565f161..b0f12a11c3b1a 100644
--- a/src/Compilers/Core/Portable/PEWriter/ReferenceIndexer.cs
+++ b/src/Compilers/Core/Portable/PEWriter/ReferenceIndexer.cs
@@ -23,7 +23,7 @@ public override void Visit(CommonPEModuleBuilder module)
         {
             // Visit these assembly-level attributes even when producing a module.
             // They'll be attached off the "AssemblyAttributesGoHere" typeRef if a module is being produced.
-            Visit(module.GetSourceAssemblyAttributes());
+            Visit(module.GetSourceAssemblyAttributes(Context.IsRefAssembly));
             Visit(module.GetSourceAssemblySecurityAttributes());
 
             Visit(module.GetAssemblyReferences(Context));
diff --git a/src/Compilers/Core/Portable/PEWriter/ReferenceIndexerBase.cs b/src/Compilers/Core/Portable/PEWriter/ReferenceIndexerBase.cs
index 9287bcecffc2a..887671429c747 100644
--- a/src/Compilers/Core/Portable/PEWriter/ReferenceIndexerBase.cs
+++ b/src/Compilers/Core/Portable/PEWriter/ReferenceIndexerBase.cs
@@ -279,7 +279,7 @@ public override void Visit(ITypeDefinition typeDefinition)
         {
             VisitTypeDefinitionNoMembers(typeDefinition);
 
-            this.Visit(typeDefinition.Events);
+            this.Visit(typeDefinition.GetEvents(Context));
             this.Visit(typeDefinition.GetFields(Context));
             this.Visit(typeDefinition.GetMethods(Context));
             this.VisitNestedTypes(typeDefinition.GetNestedTypes(Context));
diff --git a/src/Compilers/Core/Portable/PEWriter/RootModuleType.cs b/src/Compilers/Core/Portable/PEWriter/RootModuleType.cs
index 6efd067885c4f..a5e256bbbac34 100644
--- a/src/Compilers/Core/Portable/PEWriter/RootModuleType.cs
+++ b/src/Compilers/Core/Portable/PEWriter/RootModuleType.cs
@@ -49,9 +49,9 @@ public ITypeReference GetBaseClass(EmitContext context)
             return null;
         }
 
-        public IEnumerable<IEventDefinition> Events
+        public IEnumerable<IEventDefinition> GetEvents(EmitContext context)
         {
-            get { return SpecializedCollections.EmptyEnumerable<IEventDefinition>(); }
+            return SpecializedCollections.EmptyEnumerable<IEventDefinition>();
         }
 
         public IEnumerable<MethodImplementation> GetExplicitImplementationOverrides(EmitContext context)
diff --git a/src/Compilers/Core/Portable/PEWriter/Types.cs b/src/Compilers/Core/Portable/PEWriter/Types.cs
index bc6634c760bbd..841fbacf758b2 100644
--- a/src/Compilers/Core/Portable/PEWriter/Types.cs
+++ b/src/Compilers/Core/Portable/PEWriter/Types.cs
@@ -433,7 +433,7 @@ internal interface ITypeDefinition : IDefinition, ITypeReference
         /// <summary>
         /// Zero or more events defined by this type.
         /// </summary>
-        IEnumerable<IEventDefinition> Events { get; }
+        IEnumerable<IEventDefinition> GetEvents(EmitContext context);
 
         /// <summary>
         /// Zero or more implementation overrides provided by the class.
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index d3935e7a9c429..b696246816cd8 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -80,7 +80,7 @@ Microsoft.CodeAnalysis.EmbeddedText
 Microsoft.CodeAnalysis.EmbeddedText.Checksum.get -> System.Collections.Immutable.ImmutableArray<byte>
 Microsoft.CodeAnalysis.EmbeddedText.ChecksumAlgorithm.get -> Microsoft.CodeAnalysis.Text.SourceHashAlgorithm
 Microsoft.CodeAnalysis.EmbeddedText.FilePath.get -> string
-Microsoft.CodeAnalysis.Emit.EmitOptions.EmitOptions(bool metadataOnly = false, Microsoft.CodeAnalysis.Emit.DebugInformationFormat debugInformationFormat = (Microsoft.CodeAnalysis.Emit.DebugInformationFormat)0, string pdbFilePath = null, string outputNameOverride = null, int fileAlignment = 0, ulong baseAddress = 0, bool highEntropyVirtualAddressSpace = false, Microsoft.CodeAnalysis.SubsystemVersion subsystemVersion = default(Microsoft.CodeAnalysis.SubsystemVersion), string runtimeMetadataVersion = null, bool tolerateErrors = false, bool includePrivateMembers = false, System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Emit.InstrumentationKind> instrumentationKinds = default(System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Emit.InstrumentationKind>)) -> void
+Microsoft.CodeAnalysis.Emit.EmitOptions.EmitOptions(bool metadataOnly = false, Microsoft.CodeAnalysis.Emit.DebugInformationFormat debugInformationFormat = (Microsoft.CodeAnalysis.Emit.DebugInformationFormat)0, string pdbFilePath = null, string outputNameOverride = null, int fileAlignment = 0, ulong baseAddress = 0, bool highEntropyVirtualAddressSpace = false, Microsoft.CodeAnalysis.SubsystemVersion subsystemVersion = default(Microsoft.CodeAnalysis.SubsystemVersion), string runtimeMetadataVersion = null, bool tolerateErrors = false, bool includePrivateMembers = true, System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Emit.InstrumentationKind> instrumentationKinds = default(System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Emit.InstrumentationKind>)) -> void
 Microsoft.CodeAnalysis.Emit.EmitOptions.EmitOptions(bool metadataOnly, Microsoft.CodeAnalysis.Emit.DebugInformationFormat debugInformationFormat, string pdbFilePath, string outputNameOverride, int fileAlignment, ulong baseAddress, bool highEntropyVirtualAddressSpace, Microsoft.CodeAnalysis.SubsystemVersion subsystemVersion, string runtimeMetadataVersion, bool tolerateErrors, bool includePrivateMembers) -> void
 Microsoft.CodeAnalysis.Emit.EmitOptions.InstrumentationKinds.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Emit.InstrumentationKind>
 Microsoft.CodeAnalysis.Emit.EmitOptions.WithInstrumentationKinds(System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Emit.InstrumentationKind> instrumentationKinds) -> Microsoft.CodeAnalysis.Emit.EmitOptions
diff --git a/src/Compilers/Core/Portable/Symbols/Attributes/AttributeDescription.cs b/src/Compilers/Core/Portable/Symbols/Attributes/AttributeDescription.cs
index 7e2d9840a954c..d8afa2d0cbf89 100644
--- a/src/Compilers/Core/Portable/Symbols/Attributes/AttributeDescription.cs
+++ b/src/Compilers/Core/Portable/Symbols/Attributes/AttributeDescription.cs
@@ -322,6 +322,8 @@ static AttributeDescription()
             s_signature_HasThis_Void_CompilationRelaxations
         };
 
+        private static readonly byte[][] s_signaturesOfReferenceAssemblyAttribute = { s_signature_HasThis_Void };
+
         private static readonly byte[][] s_signaturesOfDebuggableAttribute =
         {
             s_signature_HasThis_Void_Boolean_Boolean,
@@ -474,6 +476,7 @@ static AttributeDescription()
         internal static readonly AttributeDescription AsyncStateMachineAttribute = new AttributeDescription("System.Runtime.CompilerServices", "AsyncStateMachineAttribute", s_signaturesOfAsyncStateMachineAttribute);
         internal static readonly AttributeDescription IteratorStateMachineAttribute = new AttributeDescription("System.Runtime.CompilerServices", "IteratorStateMachineAttribute", s_signaturesOfIteratorStateMachineAttribute);
         internal static readonly AttributeDescription CompilationRelaxationsAttribute = new AttributeDescription("System.Runtime.CompilerServices", "CompilationRelaxationsAttribute", s_signaturesOfCompilationRelaxationsAttribute);
+        internal static readonly AttributeDescription ReferenceAssemblyAttribute = new AttributeDescription("System.Runtime.CompilerServices", "ReferenceAssemblyAttribute", s_signaturesOfReferenceAssemblyAttribute);
         internal static readonly AttributeDescription RuntimeCompatibilityAttribute = new AttributeDescription("System.Runtime.CompilerServices", "RuntimeCompatibilityAttribute", s_signaturesOfRuntimeCompatibilityAttribute);
         internal static readonly AttributeDescription DebuggableAttribute = new AttributeDescription("System.Diagnostics", "DebuggableAttribute", s_signaturesOfDebuggableAttribute);
         internal static readonly AttributeDescription TypeForwardedToAttribute = new AttributeDescription("System.Runtime.CompilerServices", "TypeForwardedToAttribute", s_signaturesOfTypeForwardedToAttribute);
diff --git a/src/Compilers/Core/Portable/Symbols/Attributes/CommonAssemblyWellKnownAttributeData.cs b/src/Compilers/Core/Portable/Symbols/Attributes/CommonAssemblyWellKnownAttributeData.cs
index e68997e7d2062..1d71fc6009859 100644
--- a/src/Compilers/Core/Portable/Symbols/Attributes/CommonAssemblyWellKnownAttributeData.cs
+++ b/src/Compilers/Core/Portable/Symbols/Attributes/CommonAssemblyWellKnownAttributeData.cs
@@ -323,6 +323,24 @@ public bool HasCompilationRelaxationsAttribute
         }
         #endregion
 
+        #region ReferenceAssemblyeAttribute
+        private bool _hasReferenceAssemblyAttribute;
+        public bool HasReferenceAssemblyAttribute
+        {
+            get
+            {
+                VerifySealed(expected: true);
+                return _hasReferenceAssemblyAttribute;
+            }
+            set
+            {
+                VerifySealed(expected: false);
+                _hasReferenceAssemblyAttribute = value;
+                SetDataStored();
+            }
+        }
+        #endregion
+
         #region RuntimeCompatibilityAttribute
 
         private bool? _runtimeCompatibilityWrapNonExceptionThrows;
diff --git a/src/Compilers/Core/Portable/Symbols/ISourceAssemblySymbolInternal.cs b/src/Compilers/Core/Portable/Symbols/ISourceAssemblySymbolInternal.cs
index e2c779d15062a..d754d4c3c2543 100644
--- a/src/Compilers/Core/Portable/Symbols/ISourceAssemblySymbolInternal.cs
+++ b/src/Compilers/Core/Portable/Symbols/ISourceAssemblySymbolInternal.cs
@@ -17,5 +17,7 @@ internal interface ISourceAssemblySymbolInternal : ISourceAssemblySymbol
         AssemblyHashAlgorithm HashAlgorithm { get; }
 
         Version AssemblyVersionPattern { get; }
+
+        bool InternalsAreVisible { get; }
     }
 }
diff --git a/src/Compilers/Core/Portable/WellKnownMember.cs b/src/Compilers/Core/Portable/WellKnownMember.cs
index 341ed960772ca..3b054a306fcbc 100644
--- a/src/Compilers/Core/Portable/WellKnownMember.cs
+++ b/src/Compilers/Core/Portable/WellKnownMember.cs
@@ -415,6 +415,7 @@ internal enum WellKnownMember
         System_String__Format_IFormatProvider,
 
         Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayload,
+        System_Runtime_CompilerServices_ReferenceAssemblyAttribute__ctor,
 
         Count
     }
diff --git a/src/Compilers/Core/Portable/WellKnownMembers.cs b/src/Compilers/Core/Portable/WellKnownMembers.cs
index 8cac8670c4e3c..9a972169f8329 100644
--- a/src/Compilers/Core/Portable/WellKnownMembers.cs
+++ b/src/Compilers/Core/Portable/WellKnownMembers.cs
@@ -2878,6 +2878,13 @@ static WellKnownMembers()
                     (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,
                     (byte)SignatureTypeCode.ByReference, (byte)SignatureTypeCode.SZArray, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Boolean,
                     (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,
+
+                // System_Runtime_CompilerServices_ReferenceAssemblyAttribute__ctor
+                (byte)MemberFlags.Constructor,                                                                                                      // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.System_Runtime_CompilerServices_ReferenceAssemblyAttribute - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                  // Arity
+                    0,                                                                                                                              // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,
             };
 
             string[] allNames = new string[(int)WellKnownMember.Count]
@@ -3236,6 +3243,8 @@ static WellKnownMembers()
 
                 "Format",                                   // System_String__Format_IFormatProvider
                 "CreatePayload",                            // Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayload
+
+                ".ctor",                                    // System_Runtime_CompilerServices_ReferenceAssemblyAttribute__ctor
             };
 
             s_descriptors = MemberDescriptor.InitializeFromStream(new System.IO.MemoryStream(initializationBytes, writable: false), allNames);
diff --git a/src/Compilers/Core/Portable/WellKnownTypes.cs b/src/Compilers/Core/Portable/WellKnownTypes.cs
index 5641cd6a02dd9..6a59f6c763626 100644
--- a/src/Compilers/Core/Portable/WellKnownTypes.cs
+++ b/src/Compilers/Core/Portable/WellKnownTypes.cs
@@ -263,6 +263,7 @@ internal enum WellKnownType
         System_Runtime_CompilerServices_TupleElementNamesAttribute,
 
         Microsoft_CodeAnalysis_Runtime_Instrumentation,
+        System_Runtime_CompilerServices_ReferenceAssemblyAttribute,
 
         NextAvailable,
     }
@@ -519,7 +520,9 @@ internal static class WellKnownTypes
 
             "System.Runtime.CompilerServices.TupleElementNamesAttribute",
 
-            "Microsoft.CodeAnalysis.Runtime.Instrumentation"
+            "Microsoft.CodeAnalysis.Runtime.Instrumentation",
+
+            "System.Runtime.CompilerServices.ReferenceAssemblyAttribute"
         };
 
         private readonly static Dictionary<string, WellKnownType> s_nameToTypeIdMap = new Dictionary<string, WellKnownType>((int)Count);
diff --git a/src/Compilers/VisualBasic/Portable/BasicCodeAnalysis.vbproj b/src/Compilers/VisualBasic/Portable/BasicCodeAnalysis.vbproj
index 924ff675aeaae..0e0d51ff1089a 100644
--- a/src/Compilers/VisualBasic/Portable/BasicCodeAnalysis.vbproj
+++ b/src/Compilers/VisualBasic/Portable/BasicCodeAnalysis.vbproj
@@ -329,6 +329,7 @@
     <Compile Include="DocumentationComments\DocumentationCommentIDVisitor.vb" />
     <Compile Include="DocumentationComments\PEDocumenationCommentUtils.vb" />
     <Compile Include="DocumentationComments\SourceDocumentationCommentUtils.vb" />
+    <Compile Include="Emit\SourceAssemblySymbolAdapter.vb" />
     <Compile Include="Emit\ArrayTypeSymbolAdapter.vb" />
     <Compile Include="Emit\AssemblyReference.vb" />
     <Compile Include="Emit\AttributeDataAdapter.vb" />
diff --git a/src/Compilers/VisualBasic/Portable/CodeGen/EmitStatement.vb b/src/Compilers/VisualBasic/Portable/CodeGen/EmitStatement.vb
index c22ba0ad08bb9..e0d1a44f9304f 100644
--- a/src/Compilers/VisualBasic/Portable/CodeGen/EmitStatement.vb
+++ b/src/Compilers/VisualBasic/Portable/CodeGen/EmitStatement.vb
@@ -1422,7 +1422,7 @@ OtherExpressions:
         Private Sub EmitStateMachineScope(scope As BoundStateMachineScope)
             _builder.OpenLocalScope()
 
-            If _module.EmitOptions.DebugInformationFormat = DebugInformationFormat.Pdb Then
+            If _module.debugInformationFormat = DebugInformationFormat.Pdb Then
                 'Native PDBs: VB EE uses name mangling to match up original locals and the fields where they are hoisted
                 'The scoping information is passed by recording PDB scopes of "fake" locals named the same 
                 'as the fields. These locals are not emitted to IL.
diff --git a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
index 2e59edc2fae68..db39bd14ca19b 100644
--- a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
+++ b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
@@ -97,7 +97,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Dim utf8output As Boolean = False
             Dim outputFileName As String = Nothing
             Dim outputRefFileName As String = Nothing
-            Dim metadataOnly As Boolean = False
+            Dim refOnly As Boolean = False
             Dim outputDirectory As String = baseDirectory
             Dim documentationPath As String = Nothing
             Dim errorLogPath As String = Nothing
@@ -471,7 +471,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                 AddDiagnostic(diagnostics, ERRID.ERR_SwitchNeedsBool, "refonly")
                             End If
 
-                            metadataOnly = True
+                            refOnly = True
                             Continue For
 
 
@@ -1197,11 +1197,11 @@ lVbRuntimePlus:
                 specificDiagnosticOptions(item.Key) = item.Value
             Next
 
-            If metadataOnly AndAlso outputRefFileName IsNot Nothing Then
+            If refOnly AndAlso outputRefFileName IsNot Nothing Then
                 AddDiagnostic(diagnostics, ERRID.ERR_NoRefOutWhenRefOnly)
             End If
 
-            If outputKind = OutputKind.NetModule AndAlso (metadataOnly OrElse outputRefFileName IsNot Nothing) Then
+            If outputKind = OutputKind.NetModule AndAlso (refOnly OrElse outputRefFileName IsNot Nothing) Then
                 AddDiagnostic(diagnostics, ERRID.ERR_NoNetModuleOutputWhenRefOutOrRefOnly)
             End If
 
@@ -1353,7 +1353,8 @@ lVbRuntimePlus:
                 reportSuppressedDiagnostics:=reportSuppressedDiagnostics)
 
             Dim emitOptions = New EmitOptions(
-                metadataOnly:=metadataOnly,
+                metadataOnly:=refOnly,
+                includePrivateMembers:=Not refOnly AndAlso outputRefFileName Is Nothing,
                 debugInformationFormat:=debugInformationFormat,
                 pdbFilePath:=Nothing, ' to be determined later
                 outputNameOverride:=Nothing,  ' to be determined later
@@ -1413,7 +1414,7 @@ lVbRuntimePlus:
                 .ScriptArguments = scriptArgs.AsImmutableOrEmpty(),
                 .TouchedFilesPath = touchedFilesPath,
                 .OutputLevel = outputLevel,
-                .EmitPdb = emitPdb AndAlso Not metadataOnly, ' Silently ignore emitPdb when metadataOnly is set
+                .EmitPdb = emitPdb AndAlso Not refOnly, ' Silently ignore emitPdb when refOnly is set
                 .SourceLink = sourceLink,
                 .DefaultCoreLibraryReference = defaultCoreLibraryReference,
                 .PreferredUILang = preferredUILang,
diff --git a/src/Compilers/VisualBasic/Portable/Compilation/MethodCompiler.vb b/src/Compilers/VisualBasic/Portable/Compilation/MethodCompiler.vb
index 10348ad1f7c0c..ba54dbfeab21f 100644
--- a/src/Compilers/VisualBasic/Portable/Compilation/MethodCompiler.vb
+++ b/src/Compilers/VisualBasic/Portable/Compilation/MethodCompiler.vb
@@ -21,6 +21,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Private ReadOnly _compilation As VisualBasicCompilation
         Private ReadOnly _cancellationToken As CancellationToken
         Private ReadOnly _emittingPdb As Boolean
+        Private ReadOnly _emitTestCoverageData As Boolean
         Private ReadOnly _diagnostics As DiagnosticBag
         Private ReadOnly _hasDeclarationErrors As Boolean
         Private ReadOnly _moduleBeingBuiltOpt As PEModuleBuilder ' Nothing if compiling for diagnostics
@@ -78,6 +79,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Private Sub New(compilation As VisualBasicCompilation,
                        moduleBeingBuiltOpt As PEModuleBuilder,
                        emittingPdb As Boolean,
+                       emitTestCoverageData As Boolean,
                        doEmitPhase As Boolean,
                        hasDeclarationErrors As Boolean,
                        diagnostics As DiagnosticBag,
@@ -91,9 +93,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             _cancellationToken = cancellationToken
             _doEmitPhase = doEmitPhase
             _emittingPdb = emittingPdb
+            _emitTestCoverageData = emitTestCoverageData
             _filterOpt = filter
 
-            If emittingPdb OrElse moduleBeingBuiltOpt?.EmitOptions.EmitTestCoverageData Then
+            If emittingPdb OrElse emitTestCoverageData Then
                 _debugDocumentProvider = Function(path As String, basePath As String) moduleBeingBuiltOpt.DebugDocumentsBuilder.GetOrAddDebugDocument(path, basePath, AddressOf CreateDebugDocumentForFile)
             End If
 
@@ -155,6 +158,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Dim compiler = New MethodCompiler(compilation,
                                               moduleBeingBuiltOpt:=Nothing,
                                               emittingPdb:=False,
+                                              emitTestCoverageData:=False,
                                               doEmitPhase:=doEmitPhase,
                                               hasDeclarationErrors:=hasDeclarationErrors,
                                               diagnostics:=diagnostics,
@@ -187,6 +191,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Friend Shared Sub CompileMethodBodies(compilation As VisualBasicCompilation,
                                               moduleBeingBuiltOpt As PEModuleBuilder,
                                               emittingPdb As Boolean,
+                                              emitTestCoverageData As Boolean,
                                               hasDeclarationErrors As Boolean,
                                               filter As Predicate(Of Symbol),
                                               diagnostics As DiagnosticBag,
@@ -209,6 +214,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Dim compiler = New MethodCompiler(compilation,
                                               moduleBeingBuiltOpt,
                                               emittingPdb,
+                                              emitTestCoverageData,
                                               doEmitPhase:=True,
                                               hasDeclarationErrors:=hasDeclarationErrors,
                                               diagnostics:=diagnostics,
@@ -286,6 +292,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                  debugDocumentProvider:=Nothing,
                                                  diagnostics:=diagnostics,
                                                  emittingPdb:=False,
+                                                 emitTestCoverageData:=False,
                                                  dynamicAnalysisSpans:=ImmutableArray(Of SourceSpan).Empty)
                 moduleBeingBuilt.SetMethodBody(synthesizedEntryPoint, emittedBody)
             End If
@@ -847,9 +854,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                          closureDebugInfo:=ImmutableArray(Of ClosureDebugInfo).Empty,
                                                          stateMachineTypeOpt:=Nothing,
                                                          variableSlotAllocatorOpt:=Nothing,
-                                                         debugDocumentProvider:=If(_moduleBeingBuiltOpt?.EmitOptions.EmitTestCoverageData, _debugDocumentProvider, Nothing),
+                                                         debugDocumentProvider:=If(_emitTestCoverageData, _debugDocumentProvider, Nothing),
                                                          diagnostics:=diagnosticsThisMethod,
                                                          emittingPdb:=False,
+                                                         emitTestCoverageData:=_emitTestCoverageData,
                                                          dynamicAnalysisSpans:=ImmutableArray(Of SourceSpan).Empty)
 
                     _diagnostics.AddRange(diagnosticsThisMethod)
@@ -923,6 +931,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                              debugDocumentProvider:=Nothing,
                                                              diagnostics:=diagnosticsThisMethod,
                                                              emittingPdb:=False,
+                                                             emitTestCoverageData:=False,
                                                              dynamicAnalysisSpans:=dynamicAnalysisSpans)
                         End If
 
@@ -973,6 +982,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                          debugDocumentProvider:=_debugDocumentProvider,
                                                          diagnostics:=diagnosticsThisMethod,
                                                          emittingPdb:=_emittingPdb,
+                                                         emitTestCoverageData:=_emitTestCoverageData,
                                                          dynamicAnalysisSpans:=ImmutableArray(Of SourceSpan).Empty)
 
                     _diagnostics.AddRange(diagnosticsThisMethod)
@@ -1405,14 +1415,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Dim lambdaDebugInfoBuilder = ArrayBuilder(Of LambdaDebugInfo).GetInstance()
             Dim closureDebugInfoBuilder = ArrayBuilder(Of ClosureDebugInfo).GetInstance()
             Dim dynamicAnalysisSpans As ImmutableArray(Of SourceSpan) = ImmutableArray(Of SourceSpan).Empty
-            Dim emitDynamicAnalysisData As Boolean? = _moduleBeingBuiltOpt?.EmitOptions.EmitTestCoverageData
 
             body = Rewriter.LowerBodyOrInitializer(method,
                                                    methodOrdinal,
                                                    body,
                                                    previousSubmissionFields,
                                                    compilationState,
-                                                   emitDynamicAnalysisData.HasValue AndAlso emitDynamicAnalysisData.Value,
+                                                   _emitTestCoverageData,
                                                    dynamicAnalysisSpans,
                                                    _debugDocumentProvider,
                                                    diagnostics,
@@ -1462,6 +1471,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                               _debugDocumentProvider,
                                                               diagnostics,
                                                               emittingPdb:=_emittingPdb,
+                                                              emitTestCoverageData:=_emitTestCoverageData,
                                                               dynamicAnalysisSpans:=dynamicAnalysisSpans)
 
             If diagnostics IsNot diagsForCurrentMethod Then
@@ -1486,6 +1496,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                   debugDocumentProvider As DebugDocumentProvider,
                                                   diagnostics As DiagnosticBag,
                                                   emittingPdb As Boolean,
+                                                  emitTestCoverageData As Boolean,
                                                   dynamicAnalysisSpans As ImmutableArray(Of SourceSpan)) As MethodBody
 
             Dim compilation = moduleBuilder.Compilation
@@ -1566,7 +1577,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 Dim localScopes = builder.GetAllScopes()
 
                 Dim dynamicAnalysisDataOpt As DynamicAnalysisMethodBodyData = Nothing
-                If moduleBuilder.EmitOptions.EmitTestCoverageData Then
+                If emitTestCoverageData Then
                     Debug.Assert(debugDocumentProvider IsNot Nothing)
                     dynamicAnalysisDataOpt = New DynamicAnalysisMethodBodyData(dynamicAnalysisSpans)
                 End If
diff --git a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
index 798d084a9e8ad..bbb44f49d5c2b 100644
--- a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
+++ b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
@@ -2213,6 +2213,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Friend Overrides Function CompileMethods(
             moduleBuilder As CommonPEModuleBuilder,
             emittingPdb As Boolean,
+            emitMetadataOnly As Boolean,
+            emitTestCoverageData As Boolean,
             diagnostics As DiagnosticBag,
             filterOpt As Predicate(Of ISymbol),
             cancellationToken As CancellationToken) As Boolean
@@ -2232,7 +2234,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 moduleBeingBuilt.TranslateImports(diagnostics)
             End If
 
-            If moduleBeingBuilt.EmitOptions.EmitMetadataOnly Then
+            If emitMetadataOnly Then
                 If hasDeclarationErrors Then
                     Return False
                 End If
@@ -2246,7 +2248,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 SynthesizedMetadataCompiler.ProcessSynthesizedMembers(Me, moduleBeingBuilt, cancellationToken)
             Else
                 ' start generating PDB checksums if we need to emit PDBs
-                If (emittingPdb OrElse moduleBeingBuilt.EmitOptions.EmitTestCoverageData) AndAlso
+                If (emittingPdb OrElse emitTestCoverageData) AndAlso
                    Not CreateDebugDocuments(moduleBeingBuilt.DebugDocumentsBuilder, moduleBeingBuilt.EmbeddedTexts, diagnostics) Then
                     Return False
                 End If
@@ -2261,6 +2263,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                     Me,
                     moduleBeingBuilt,
                     emittingPdb,
+                    emitTestCoverageData,
                     hasDeclarationErrors,
                     filterOpt,
                     methodBodyDiagnosticBag,
@@ -2282,6 +2285,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             moduleBuilder As CommonPEModuleBuilder,
             xmlDocStream As Stream,
             win32Resources As Stream,
+            outputNameOverride As String,
             diagnostics As DiagnosticBag,
             cancellationToken As CancellationToken) As Boolean
 
@@ -2306,7 +2310,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             ' Use a temporary bag so we don't have to refilter pre-existing diagnostics.
             Dim xmlDiagnostics = DiagnosticBag.GetInstance()
 
-            Dim assemblyName = FileNameUtilities.ChangeExtension(moduleBuilder.EmitOptions.OutputNameOverride, extension:=Nothing)
+            Dim assemblyName = FileNameUtilities.ChangeExtension(outputNameOverride, extension:=Nothing)
             DocumentationCommentCompiler.WriteDocumentationCommentXml(Me, assemblyName, xmlDocStream, xmlDiagnostics, cancellationToken)
 
             Return FilterAndAppendAndFreeDiagnostics(diagnostics, xmlDiagnostics)
diff --git a/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/EmitHelpers.vb b/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/EmitHelpers.vb
index e771efcfdd5ee..b3e4e82236c5b 100644
--- a/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/EmitHelpers.vb
+++ b/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/EmitHelpers.vb
@@ -81,6 +81,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit
                     updatedMethods,
                     diagnostics,
                     testData?.SymWriterFactory,
+                    emitOpts.PdbFilePath,
                     cancellationToken)
             End If
 
@@ -109,8 +110,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit
             ' Mapping from previous compilation to the current.
             Dim anonymousTypeMap = moduleBeingBuilt.GetAnonymousTypeMap()
             Dim sourceAssembly = DirectCast(previousGeneration.Compilation, VisualBasicCompilation).SourceAssembly
-            Dim sourceContext = New EmitContext(DirectCast(previousGeneration.PEModuleBuilder, PEModuleBuilder), Nothing, New DiagnosticBag())
-            Dim otherContext = New EmitContext(moduleBeingBuilt, Nothing, New DiagnosticBag())
+            Dim sourceContext = New EmitContext(DirectCast(previousGeneration.PEModuleBuilder, PEModuleBuilder), Nothing, New DiagnosticBag(), metadataOnly:=False, includePrivateMembers:=True)
+            Dim otherContext = New EmitContext(moduleBeingBuilt, Nothing, New DiagnosticBag(), metadataOnly:=False, includePrivateMembers:=True)
 
             Dim matcher = New VisualBasicSymbolMatcher(
                 anonymousTypeMap,
diff --git a/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb b/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb
index 20e013d904434..1671f391e4c54 100644
--- a/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb
+++ b/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb
@@ -33,7 +33,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit
             MyBase.New(sourceAssembly, emitOptions, outputKind, serializationProperties, manifestResources, additionalTypes:=ImmutableArray(Of NamedTypeSymbol).Empty)
 
             Dim initialBaseline = previousGeneration.InitialBaseline
-            Dim context = New EmitContext(Me, Nothing, New DiagnosticBag())
+            Dim context = New EmitContext(Me, Nothing, New DiagnosticBag(), metadataOnly:=False, includePrivateMembers:=True)
 
             ' Hydrate symbols from initial metadata. Once we do so it is important to reuse these symbols across all generations,
             ' in order for the symbol matcher to be able to use reference equality once it maps symbols to initial metadata.
@@ -46,7 +46,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit
             Dim matchToPrevious As VisualBasicSymbolMatcher = Nothing
             If previousGeneration.Ordinal > 0 Then
                 Dim previousAssembly = DirectCast(previousGeneration.Compilation, VisualBasicCompilation).SourceAssembly
-                Dim previousContext = New EmitContext(DirectCast(previousGeneration.PEModuleBuilder, PEModuleBuilder), Nothing, New DiagnosticBag())
+                Dim previousContext = New EmitContext(DirectCast(previousGeneration.PEModuleBuilder, PEModuleBuilder), Nothing, New DiagnosticBag(), metadataOnly:=False, includePrivateMembers:=True)
 
                 matchToPrevious = New VisualBasicSymbolMatcher(
                     previousGeneration.AnonymousTypeMap,
diff --git a/src/Compilers/VisualBasic/Portable/Emit/NamedTypeSymbolAdapter.vb b/src/Compilers/VisualBasic/Portable/Emit/NamedTypeSymbolAdapter.vb
index 03076eefb3eeb..8375d049798a2 100644
--- a/src/Compilers/VisualBasic/Portable/Emit/NamedTypeSymbolAdapter.vb
+++ b/src/Compilers/VisualBasic/Portable/Emit/NamedTypeSymbolAdapter.vb
@@ -232,18 +232,20 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
             Return Nothing
         End Function
 
-        Private ReadOnly Property ITypeDefinitionEvents As IEnumerable(Of IEventDefinition) Implements ITypeDefinition.Events
-            Get
-                Debug.Assert(Not Me.IsAnonymousType)
-                'Debug.Assert(((ITypeReference)this).AsTypeDefinition != null);
+        Private Iterator Function ITypeDefinitionEvents(context As EmitContext) As IEnumerable(Of IEventDefinition) Implements ITypeDefinition.GetEvents
+            Debug.Assert(Not Me.IsAnonymousType)
+            'Debug.Assert(((ITypeReference)this).AsTypeDefinition != null);
 
-                ' can't be generic instantiation
-                ' must be declared in the module we are building
-                CheckDefinitionInvariant()
+            ' can't be generic instantiation
+            ' must be declared in the module we are building
+            CheckDefinitionInvariant()
 
-                Return GetEventsToEmit()
-            End Get
-        End Property
+            For Each e In GetEventsToEmit()
+                If e.ShouldInclude(context) Then
+                    Yield e
+                End If
+            Next
+        End Function
 
         Friend Overridable Iterator Function GetEventsToEmit() As IEnumerable(Of EventSymbol)
             CheckDefinitionInvariant()
@@ -329,14 +331,21 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
             ' must be declared in the module we are building
             CheckDefinitionInvariant()
 
+            ' All fields in a struct should be emitted
+            Dim isStruct = Me.IsStructureType()
+
             For Each field In Me.GetFieldsToEmit()
-                Yield field
+                If isStruct OrElse field.ShouldInclude(context) Then
+                    Yield field
+                End If
             Next
 
             Dim syntheticFields = DirectCast(context.Module, PEModuleBuilder).GetSynthesizedFields(Me)
             If syntheticFields IsNot Nothing Then
                 For Each field In syntheticFields
-                    Yield field
+                    If isStruct OrElse field.ShouldInclude(context) Then
+                        Yield field
+                    End If
                 Next
             End If
         End Function
@@ -661,13 +670,17 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
             CheckDefinitionInvariant()
 
             For Each method In Me.GetMethodsToEmit()
-                Yield method
+                If method.ShouldInclude(context) Then
+                    Yield method
+                End If
             Next
 
             Dim syntheticMethods = DirectCast(context.Module, PEModuleBuilder).GetSynthesizedMethods(Me)
             If syntheticMethods IsNot Nothing Then
                 For Each method In syntheticMethods
-                    Yield method
+                    If method.ShouldInclude(context) Then
+                        Yield method
+                    End If
                 Next
             End If
         End Function
@@ -726,13 +739,17 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
 
             For Each [property] In Me.GetPropertiesToEmit()
                 Debug.Assert([property] IsNot Nothing)
-                Yield [property]
+                If [property].ShouldInclude(context) Then
+                    Yield [property]
+                End If
             Next
 
             Dim syntheticProperties = DirectCast(context.Module, PEModuleBuilder).GetSynthesizedProperties(Me)
             If syntheticProperties IsNot Nothing Then
                 For Each prop In syntheticProperties
-                    Yield prop
+                    If prop.ShouldInclude(context) Then
+                        Yield prop
+                    End If
                 Next
             End If
         End Function
diff --git a/src/Compilers/VisualBasic/Portable/Emit/NoPia/EmbeddedTypesManager.vb b/src/Compilers/VisualBasic/Portable/Emit/NoPia/EmbeddedTypesManager.vb
index 2c8af65584bdc..5726579784f22 100644
--- a/src/Compilers/VisualBasic/Portable/Emit/NoPia/EmbeddedTypesManager.vb
+++ b/src/Compilers/VisualBasic/Portable/Emit/NoPia/EmbeddedTypesManager.vb
@@ -278,7 +278,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit.NoPia
             ' We do not expect this method to be called on a different thread once GetTypes is called.
             VerifyNotFrozen()
 
-            Dim noPiaIndexer = New Cci.NoPiaReferenceIndexer(New EmitContext(ModuleBeingBuilt, syntaxNodeOpt, diagnostics))
+            Dim noPiaIndexer = New Cci.NoPiaReferenceIndexer(New EmitContext(ModuleBeingBuilt, syntaxNodeOpt, diagnostics, metadataOnly:=False, includePrivateMembers:=True))
 
             ' Make sure we embed all types referenced by the type declaration: implemented interfaces, etc.
             noPiaIndexer.VisitTypeDefinitionNoMembers(embedded)
diff --git a/src/Compilers/VisualBasic/Portable/Emit/PEModuleBuilder.vb b/src/Compilers/VisualBasic/Portable/Emit/PEModuleBuilder.vb
index b0424cf0b3bff..4cb385e14dc9e 100644
--- a/src/Compilers/VisualBasic/Portable/Emit/PEModuleBuilder.vb
+++ b/src/Compilers/VisualBasic/Portable/Emit/PEModuleBuilder.vb
@@ -41,7 +41,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit
 
             Dim specifiedName = sourceModule.MetadataName
 
-            _metadataName = If(specifiedName <> Microsoft.CodeAnalysis.Compilation.UnspecifiedModuleAssemblyName,
+            _metadataName = If(specifiedName <> CodeAnalysis.Compilation.UnspecifiedModuleAssemblyName,
                                 specifiedName,
                                 If(emitOptions.OutputNameOverride, specifiedName))
 
@@ -176,8 +176,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit
             Return Me.Compilation.TrySynthesizeAttribute(attributeConstructor)
         End Function
 
-        Public NotOverridable Overrides Function GetSourceAssemblyAttributes() As IEnumerable(Of Cci.ICustomAttribute)
-            Return SourceModule.ContainingSourceAssembly.GetCustomAttributesToEmit(Me.CompilationState, emittingAssemblyAttributesInNetModule:=OutputKind.IsNetModule())
+        Public NotOverridable Overrides Function GetSourceAssemblyAttributes(isRefAssembly As Boolean) As IEnumerable(Of Cci.ICustomAttribute)
+            Return SourceModule.ContainingSourceAssembly.GetAssemblyCustomAttributesToEmit(Me.CompilationState,
+                                                                                           isRefAssembly,
+                                                                                           emittingAssemblyAttributesInNetModule:=OutputKind.IsNetModule())
         End Function
 
         Public NotOverridable Overrides Function GetSourceAssemblySecurityAttributes() As IEnumerable(Of Cci.SecurityAttribute)
@@ -330,8 +332,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit
             Return False
         End Function
 
-        Friend NotOverridable Overrides Function GetAnonymousTypes() As ImmutableArray(Of Cci.INamespaceTypeDefinition)
-            If EmitOptions.EmitMetadataOnly Then
+        Friend NotOverridable Overrides Function GetAnonymousTypes(context As EmitContext) As ImmutableArray(Of Cci.INamespaceTypeDefinition)
+            If context.MetadataOnly Then
                 Return ImmutableArray(Of Cci.INamespaceTypeDefinition).Empty
             End If
 
diff --git a/src/Compilers/VisualBasic/Portable/Emit/SourceAssemblySymbolAdapter.vb b/src/Compilers/VisualBasic/Portable/Emit/SourceAssemblySymbolAdapter.vb
new file mode 100644
index 0000000000000..29d49a1530881
--- /dev/null
+++ b/src/Compilers/VisualBasic/Portable/Emit/SourceAssemblySymbolAdapter.vb
@@ -0,0 +1,24 @@
+' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
+    Partial Friend Class SourceAssemblySymbol
+
+        Friend Function GetAssemblyCustomAttributesToEmit(compilationState As ModuleCompilationState,
+                                                          emittingRefAssembly As Boolean,
+                                                          emittingAssemblyAttributesInNetModule As Boolean) As IEnumerable(Of VisualBasicAttributeData)
+
+            Dim synthesized As ArrayBuilder(Of SynthesizedAttributeData) = Nothing
+            AddSynthesizedAttributes(compilationState, synthesized)
+
+            If emittingRefAssembly AndAlso Not HasReferenceAssemblyAttribute Then
+                Dim referenceAssemblyAttribute = Me.DeclaringCompilation.
+                    TrySynthesizeAttribute(WellKnownMember.System_Runtime_CompilerServices_ReferenceAssemblyAttribute__ctor, isOptionalUse:=True)
+
+                Symbol.AddSynthesizedAttribute(synthesized, referenceAssemblyAttribute)
+            End If
+
+            Return GetCustomAttributesToEmit(Me.GetAttributes(), synthesized, isReturnType:=False, emittingAssemblyAttributesInNetModule:=emittingAssemblyAttributesInNetModule)
+        End Function
+
+    End Class
+End Namespace
diff --git a/src/Compilers/VisualBasic/Portable/Emit/SymbolAdapter.vb b/src/Compilers/VisualBasic/Portable/Emit/SymbolAdapter.vb
index c431426fe723e..af65ce3f230cb 100644
--- a/src/Compilers/VisualBasic/Portable/Emit/SymbolAdapter.vb
+++ b/src/Compilers/VisualBasic/Portable/Emit/SymbolAdapter.vb
@@ -40,6 +40,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         End Function
 
         Friend Function GetCustomAttributesToEmit(compilationState As ModuleCompilationState, emittingAssemblyAttributesInNetModule As Boolean) As IEnumerable(Of VisualBasicAttributeData)
+            Debug.Assert(Me.Kind <> SymbolKind.Assembly)
+
             Dim synthesized As ArrayBuilder(Of SynthesizedAttributeData) = Nothing
             AddSynthesizedAttributes(compilationState, synthesized)
             Return GetCustomAttributesToEmit(Me.GetAttributes(), synthesized, isReturnType:=False, emittingAssemblyAttributesInNetModule:=emittingAssemblyAttributesInNetModule)
diff --git a/src/Compilers/VisualBasic/Portable/Errors/Errors.vb b/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
index 8876c568bcb07..77eb9205a9125 100644
--- a/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
+++ b/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
@@ -1707,7 +1707,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ERR_ExplicitTupleElementNamesAttribute = 37269
         ERR_TupleLiteralDisallowsTypeChar = 37270
 
-        ' Available 37270
         ERR_DuplicateProcDefWithDifferentTupleNames2 = 37271
         ERR_InterfaceImplementedTwiceWithDifferentTupleNames2 = 37272
         ERR_InterfaceImplementedTwiceWithDifferentTupleNames3 = 37273
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceAssemblySymbol.vb b/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceAssemblySymbol.vb
index 0c84acfd3c7b1..a52f9c10e5f1c 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceAssemblySymbol.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceAssemblySymbol.vb
@@ -18,7 +18,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
     ''' Represents an assembly built by compiler.
     ''' </summary>
     ''' <remarks></remarks>
-    Friend NotInheritable Class SourceAssemblySymbol
+    Partial Friend NotInheritable Class SourceAssemblySymbol
         Inherits MetadataOrSourceAssemblySymbol
         Implements ISourceAssemblySymbolInternal, IAttributeTargetSymbol
 
@@ -1064,6 +1064,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
                 attrData.DecodeGuidAttribute(arguments.AttributeSyntaxOpt, arguments.Diagnostics)
             ElseIf attrData.IsTargetAttribute(Me, AttributeDescription.CompilationRelaxationsAttribute) Then
                 arguments.GetOrCreateData(Of CommonAssemblyWellKnownAttributeData)().HasCompilationRelaxationsAttribute = True
+            ElseIf attrData.IsTargetAttribute(Me, AttributeDescription.ReferenceAssemblyAttribute) Then
+                arguments.GetOrCreateData(Of CommonAssemblyWellKnownAttributeData)().HasReferenceAssemblyAttribute = True
             ElseIf attrData.IsTargetAttribute(Me, AttributeDescription.RuntimeCompatibilityAttribute) Then
                 ' VB doesn't need to decode argument values
                 arguments.GetOrCreateData(Of CommonAssemblyWellKnownAttributeData)().RuntimeCompatibilityWrapNonExceptionThrows = True
@@ -1382,6 +1384,20 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
             End If
         End Sub
 
+        ''' <summary>
+        ''' True if internals are exposed at all.
+        ''' </summary>
+        ''' <remarks>
+        ''' Forces binding and decoding of attributes.
+        ''' This property shouldn't be accessed during binding as it can lead to attribute binding cycle.
+        ''' </remarks>
+        Public ReadOnly Property InternalsAreVisible As Boolean Implements ISourceAssemblySymbolInternal.InternalsAreVisible
+            Get
+                EnsureAttributesAreBound()
+                Return _lazyInternalsVisibleToMap IsNot Nothing
+            End Get
+        End Property
+
         ''' <summary>
         ''' We may synthesize some well-known attributes for this assembly symbol.  However, at synthesis time, it is
         ''' too late to report diagnostics or cancel the emit.  Instead, we check for use site errors on the types and members
@@ -1422,7 +1438,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
             End Get
         End Property
 
-        Friend Overrides Sub AddSynthesizedAttributes(compilationState as ModuleCompilationState, ByRef attributes As ArrayBuilder(Of SynthesizedAttributeData))
+        Private ReadOnly Property HasReferenceAssemblyAttribute As Boolean
+            Get
+                Dim assemblyData As CommonAssemblyWellKnownAttributeData = Me.GetSourceDecodedWellKnownAttributeData()
+                Return assemblyData IsNot Nothing AndAlso assemblyData.HasReferenceAssemblyAttribute
+            End Get
+        End Property
+
+        Friend Overrides Sub AddSynthesizedAttributes(compilationState As ModuleCompilationState, ByRef attributes As ArrayBuilder(Of SynthesizedAttributeData))
             MyBase.AddSynthesizedAttributes(compilationState, attributes)
 
             Debug.Assert(_lazyEmitExtensionAttribute <> ThreeState.Unknown)
@@ -1652,8 +1675,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
                 End If
             End If
 
-                    keys = StrongNameKeys.Create(DeclaringCompilation.Options.StrongNameProvider, keyFile, keyContainer, MessageProvider.Instance)
-                Interlocked.CompareExchange(_lazyStrongNameKeys, keys, Nothing)
+            keys = StrongNameKeys.Create(DeclaringCompilation.Options.StrongNameProvider, keyFile, keyContainer, MessageProvider.Instance)
+            Interlocked.CompareExchange(_lazyStrongNameKeys, keys, Nothing)
         End Sub
 
         Private Function ComputeIdentity() As AssemblyIdentity
diff --git a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
index 3e7296cb2b476..cdf88510d19b9 100644
--- a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
+++ b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
@@ -8101,8 +8101,8 @@ End Class")
             Assert.True(File.Exists(exe))
 
             MetadataReaderUtils.VerifyPEMetadata(exe,
-                {"TypeDef:<Module>", "TypeDef:C"},
-                {"MethodDef: Void Main()", "MethodDef: Void .ctor()"},
+                {"TypeDefinition:<Module>", "TypeDefinition:C"},
+                {"MethodDefinition:Void Main()", "MethodDefinition:Void .ctor()"},
                 {"CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "STAThreadAttribute"}
                 )
 
@@ -8133,49 +8133,18 @@ a
             Assert.True(File.Exists(refDll))
 
             ' The types and members that are included needs further refinement.
-            ' ReferenceAssemblyAttribute is missing.
             ' See issue https://github.com/dotnet/roslyn/issues/17612
             MetadataReaderUtils.VerifyPEMetadata(refDll,
-                {"TypeDef:<Module>", "TypeDef:C"},
-                {"MethodDef: Void Main()", "MethodDef: Void .ctor()"},
-                {"CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "STAThreadAttribute"}
+                {"TypeDefinition:<Module>", "TypeDefinition:C"},
+                {"MethodDefinition:Void Main()", "MethodDefinition:Void .ctor()"},
+                {"CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "STAThreadAttribute", "ReferenceAssemblyAttribute"}
                 )
 
-            VerifyNullReferenceException(refDir, "a.dll")
-
             ' Clean up temp files
             CleanupAllGeneratedFiles(dir.Path)
             CleanupAllGeneratedFiles(refDir.Path)
         End Sub
 
-        ''' <summary>
-        ''' Calls C.Main() on the program and verifies that a null reference exception is thrown.
-        ''' </summary>
-        Private Shared Sub VerifyNullReferenceException(dir As TempDirectory, referenceName As String)
-
-            Dim src = dir.CreateFile("verifier.vb")
-            src.WriteAllText("
-Class Verifier
-    Public Shared Sub Main()
-        Try
-            C.Main()
-        Catch ex As System.NullReferenceException
-            System.Console.Write(""Got expected exception"")
-        End Try
-    End Sub
-End Class")
-
-            Dim outWriter = New StringWriter(CultureInfo.InvariantCulture)
-            Dim vbc = New MockVisualBasicCompiler(Nothing, dir.Path,
-                {"/define:_MYTYPE=""Empty"" ", "/nologo", "/out:verifier.exe", $"/reference:{referenceName}", "verifier.vb"})
-
-            Dim exitCode = vbc.Run(outWriter)
-            Assert.Equal(0, exitCode)
-            Dim dirPath As String = dir.ToString()
-            Dim output = ProcessUtilities.RunAndGetOutput(Path.Combine(dirPath, "verifier.exe"), startFolder:=dirPath, expectedRetCode:=0)
-            Assert.Equal("Got expected exception", output)
-        End Sub
-
         <Fact>
         Public Sub RefOutWithError()
             Dim dir = Temp.CreateDirectory()
@@ -8239,12 +8208,11 @@ End Class")
             Assert.True(File.Exists(refDll))
 
             ' The types and members that are included needs further refinement.
-            ' ReferenceAssemblyAttribute is missing.
             ' See issue https://github.com/dotnet/roslyn/issues/17612
             MetadataReaderUtils.VerifyPEMetadata(refDll,
-                {"TypeDef:<Module>", "TypeDef:C"},
-                {"MethodDef: Void Main()", "MethodDef: Void .ctor()"},
-                {"CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "STAThreadAttribute"}
+                {"TypeDefinition:<Module>", "TypeDefinition:C"},
+                {"MethodDefinition:Void Main()", "MethodDefinition:Void .ctor()"},
+                {"CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "STAThreadAttribute", "ReferenceAssemblyAttribute"}
                 )
 
             Dim pdb = Path.Combine(dir.Path, "a.pdb")
diff --git a/src/Compilers/VisualBasic/Test/Emit/Attributes/AssemblyAttributes.vb b/src/Compilers/VisualBasic/Test/Emit/Attributes/AssemblyAttributes.vb
index b74e4d966a211..767168811a64a 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Attributes/AssemblyAttributes.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Attributes/AssemblyAttributes.vb
@@ -1222,7 +1222,10 @@ End Class
         ' We should get only unique netmodule/assembly attributes here, duplicate ones should not be emitted.
         Dim expectedEmittedAttrsCount As Integer = expectedSrcAttrCount - expectedDuplicateAttrCount
 
-        Dim allEmittedAttrs = assembly.GetCustomAttributesToEmit(New ModuleCompilationState).Cast(Of VisualBasicAttributeData)()
+        Dim allEmittedAttrs = DirectCast(assembly, SourceAssemblySymbol).
+            GetAssemblyCustomAttributesToEmit(New ModuleCompilationState, emittingRefAssembly:=False, emittingAssemblyAttributesInNetModule:=False).
+            Cast(Of VisualBasicAttributeData)()
+
         Dim emittedAttrs = allEmittedAttrs.Where(Function(a) a.AttributeClass.Name.Equals(attrTypeName)).AsImmutable()
 
         Assert.Equal(expectedEmittedAttrsCount, emittedAttrs.Length)
@@ -1504,7 +1507,10 @@ End Class
             expectedDuplicateAttrCount:=1,
             attrTypeName:="AssemblyTitleAttribute")
 
-        Dim attrs = consoleappCompilation.Assembly.GetCustomAttributesToEmit(New ModuleCompilationState).Cast(Of VisualBasicAttributeData)()
+        Dim attrs = DirectCast(consoleappCompilation.Assembly, SourceAssemblySymbol).
+            GetAssemblyCustomAttributesToEmit(New ModuleCompilationState, emittingRefAssembly:=False, emittingAssemblyAttributesInNetModule:=False).
+            Cast(Of VisualBasicAttributeData)()
+
         For Each a In attrs
             Select Case a.AttributeClass.Name
                 Case "AssemblyTitleAttribute"
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
index b94de992431c0..68f38a335d6cb 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
@@ -297,59 +297,221 @@ End Class
             End Using
         End Sub
 
+        <Fact>
+        Public Sub RefAssembly_HasReferenceAssemblyAttribute()
+            Dim emitRefAssembly = EmitOptions.Default.WithEmitMetadataOnly(True).WithIncludePrivateMembers(False)
+
+            Dim assemblyValidator As Action(Of PEAssembly) =
+                Sub(assembly)
+                    Dim reader = assembly.GetMetadataReader()
+                    Dim attributes = reader.GetAssemblyDefinition().GetCustomAttributes()
+                    AssertEx.Equal(
+                        {"MemberReference:Void System.Runtime.CompilerServices.CompilationRelaxationsAttribute.ctor(Int32)",
+                            "MemberReference:Void System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.ctor()",
+                            "MemberReference:Void System.Diagnostics.DebuggableAttribute.ctor(DebuggingModes)",
+                            "MemberReference:Void System.Runtime.CompilerServices.ReferenceAssemblyAttribute.ctor()"
+                        },
+                        attributes.Select(Function(a) MetadataReaderUtils.Dump(reader, reader.GetCustomAttribute(a).Constructor)))
+                End Sub
+
+            Dim source = <compilation>
+                             <file name="a.vb"></file>
+                         </compilation>
+            CompileAndVerify(source, emitOptions:=emitRefAssembly, verify:=True, validator:=assemblyValidator)
+        End Sub
+
+        <Fact>
+        Public Sub RefAssembly_HandlesMissingReferenceAssemblyAttribute()
+            Dim emitRefAssembly = EmitOptions.Default.WithEmitMetadataOnly(True).WithIncludePrivateMembers(False)
+
+            Dim assemblyValidator As Action(Of PEAssembly) =
+                Sub(assembly)
+                    Dim reader = assembly.GetMetadataReader()
+                    Dim attributes = reader.GetAssemblyDefinition().GetCustomAttributes()
+                    AssertEx.Empty(attributes.Select(Function(a) MetadataReaderUtils.Dump(reader, reader.GetCustomAttribute(a).Constructor)))
+                End Sub
+
+            Dim comp = CreateCompilation({Parse("")})
+            comp.MakeMemberMissing(WellKnownMember.System_Runtime_CompilerServices_ReferenceAssemblyAttribute__ctor)
+            CompileAndVerify(comp, emitOptions:=emitRefAssembly, verify:=True, validator:=assemblyValidator)
+        End Sub
+
+        <Fact>
+        Public Sub RefAssembly_ReferenceAssemblyAttributeAlsoInSource()
+            Dim emitRefAssembly = EmitOptions.Default.WithEmitMetadataOnly(True).WithIncludePrivateMembers(False)
+
+            Dim assemblyValidator As Action(Of PEAssembly) =
+                Sub(assembly)
+                    Dim reader = assembly.GetMetadataReader()
+                    Dim attributes = reader.GetAssemblyDefinition().GetCustomAttributes()
+                    AssertEx.Equal(
+                        {"MemberReference:Void System.Runtime.CompilerServices.CompilationRelaxationsAttribute.ctor(Int32)",
+                            "MemberReference:Void System.Runtime.CompilerServices.RuntimeCompatibilityAttribute.ctor()",
+                            "MemberReference:Void System.Diagnostics.DebuggableAttribute.ctor(DebuggingModes)",
+                            "MemberReference:Void System.Runtime.CompilerServices.ReferenceAssemblyAttribute.ctor()"
+                        },
+                        attributes.Select(Function(a) MetadataReaderUtils.Dump(reader, reader.GetCustomAttribute(a).Constructor)))
+                End Sub
+
+            Dim source = <compilation>
+                             <file name="a.vb"><![CDATA[
+<assembly:System.Runtime.CompilerServices.ReferenceAssembly()>
+                         ]]></file>
+                         </compilation>
+            CompileAndVerify(source, emitOptions:=emitRefAssembly, verify:=True, validator:=assemblyValidator)
+        End Sub
+
         <Fact>
         Public Sub RefAssembly_InvariantToSomeChanges()
+            Dim sourceTemplate As String = "
+Public Class C
+    CHANGE
+End Class"
 
-            RefAssembly_InvariantToSomeChanges(
+            CompareAssemblies(sourceTemplate,
 "Public Function M() As Integer
     Return 1
 End Function",
 "Public Function M() As Integer
     Return 2
-End Function", True)
+End Function", Match.BothMetadataAndRefOut)
 
-            RefAssembly_InvariantToSomeChanges(
+            CompareAssemblies(sourceTemplate,
 "Public Function M() As Integer
     Return 1
 End Function",
 "Public Function M() As Integer
-End Function", True)
+    Return Bad()
+End Function", Match.BothMetadataAndRefOut)
 
-            RefAssembly_InvariantToSomeChanges(
-"",
+            CompareAssemblies(sourceTemplate,
 "Private Sub M()
-End Sub", False) ' Should be true. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
+End Sub",
+"", Match.RefOut)
 
-            RefAssembly_InvariantToSomeChanges(
+            CompareAssemblies(sourceTemplate,
 "Friend Sub M()
 End Sub",
-"", False)
+"", Match.RefOut)
 
-            RefAssembly_InvariantToSomeChanges(
+            CompareAssemblies(sourceTemplate,
+"Private Sub M()
+Dim product = New With {Key .Id = 1}
+End Sub",
+"", Match.RefOut)
+
+            CompareAssemblies(sourceTemplate,
+"Private Property P As Integer
+    Get
+        Bad()
+    End Get
+    Set
+        Bad()
+    End Set
+End Property",
+"", Match.RefOut) ' Errors in method bodies don't matter
+
+            CompareAssemblies(sourceTemplate,
+"Public Property P As Integer",
+"", Match.Different)
+
+            CompareAssemblies(sourceTemplate,
+"Protected Property P As Integer",
+"", Match.Different)
+
+            CompareAssemblies(sourceTemplate,
+"Private Property P As Integer",
+"", Match.RefOut) ' Private auto-property and underlying field are removed
+
+            CompareAssemblies(sourceTemplate,
+"Friend Property P As Integer",
+"", Match.RefOut)
+
+            CompareAssemblies(sourceTemplate,
+"Private Event DoSomething()",
+"", Match.Different) ' VB events add nested types (C.DoSomethingEventHandler in this case)
+
+            CompareAssemblies(sourceTemplate,
+"Friend Event DoSomething()",
+"", Match.Different)
+
+            CompareAssemblies(sourceTemplate,
+"Private Class C2
+End Class",
+"", Match.Different) ' All types are included
+
+            CompareAssemblies(sourceTemplate,
+"Private Structure S
+End Structure",
+"", Match.Different)
+
+            CompareAssemblies(sourceTemplate,
 "Public Structure S
     Private Dim i As Integer
 End Structure",
 "Public Structure S
-End Structure", False)
+End Structure", Match.Different)
+
+            CompareAssemblies(sourceTemplate,
+"Private Dim i As Integer",
+"", Match.RefOut)
+
+            CompareAssemblies(sourceTemplate,
+"Public Sub New()
+End Sub",
+"", Match.BothMetadataAndRefOut)
+
+            CompareAssemblies(sourceTemplate,
+"Public Function NoBody() As Integer
+End Function",
+"Public Function NoBody() As Integer
+    Return 1
+End Function", Match.BothMetadataAndRefOut)
 
         End Sub
 
-        Private Sub RefAssembly_InvariantToSomeChanges(change1 As String, change2 As String, expectMatch As Boolean)
+        <Fact>
+        Public Sub RefAssembly_InvariantToSomeChangesWithInternalsVisibleTo()
             Dim sourceTemplate As String = "
+Imports System.Runtime.CompilerServices
+<assembly:InternalsVisibleToAttribute(""Friend"")>
 Public Class C
     CHANGE
 End Class"
 
+            CompareAssemblies(sourceTemplate,
+"Friend Function M() As Integer
+End Function",
+"", Match.Different)
+
+        End Sub
+
+        Private Sub CompareAssemblies(sourceTemplate As String, left As String, right As String, expectedMatch As Match)
+            CompareAssemblies(sourceTemplate, left, right, expectedMatch, includePrivateMembers:=True)
+            CompareAssemblies(sourceTemplate, left, right, expectedMatch, includePrivateMembers:=False)
+        End Sub
+
+        Public Enum Match
+            BothMetadataAndRefOut
+            RefOut
+            Different
+        End Enum
+
+        Private Sub CompareAssemblies(sourceTemplate As String, change1 As String, change2 As String, expectedMatch As Match, includePrivateMembers As Boolean)
+            Dim expectMatch = If(includePrivateMembers,
+                expectedMatch = Match.BothMetadataAndRefOut,
+                expectedMatch = Match.BothMetadataAndRefOut OrElse expectedMatch = Match.RefOut)
+
             Dim name As String = GetUniqueName()
             Dim source1 As String = sourceTemplate.Replace("CHANGE", change1)
             Dim comp1 = CreateCompilationWithMscorlib(source1,
                 options:=TestOptions.DebugDll.WithDeterministic(True), assemblyName:=name)
-            Dim image1 As ImmutableArray(Of Byte) = comp1.EmitToArray(EmitOptions.Default.WithEmitMetadataOnly(True))
+            Dim image1 As ImmutableArray(Of Byte) = comp1.EmitToArray(EmitOptions.Default.WithEmitMetadataOnly(True).WithIncludePrivateMembers(includePrivateMembers))
 
             Dim source2 = sourceTemplate.Replace("CHANGE", change2)
             Dim comp2 = CreateCompilationWithMscorlib(source2,
                             options:=TestOptions.DebugDll.WithDeterministic(True), assemblyName:=name)
-            Dim image2 As ImmutableArray(Of Byte) = comp2.EmitToArray(EmitOptions.Default.WithEmitMetadataOnly(True))
+            Dim image2 As ImmutableArray(Of Byte) = comp2.EmitToArray(EmitOptions.Default.WithEmitMetadataOnly(True).WithIncludePrivateMembers(includePrivateMembers))
 
             If expectMatch Then
                 AssertEx.Equal(image1, image2)
@@ -358,6 +520,156 @@ End Class"
             End If
         End Sub
 
+        <Fact>
+        Public Sub RefAssemblyClient_EmitAllNestedTypes()
+            VerifyRefAssemblyClient("
+Public Interface I1(Of T)
+End Interface
+Public Interface I2
+End Interface
+Public Class A
+    Implements I1(Of A.X)
+
+    Private Class X
+        Implements I2
+
+    End Class
+End Class
+", "
+Public Class C
+    Public Function M(a As A) As I1(Of I2)
+        Return DirectCast(a, I1(Of I2))
+    End Function
+End Class
+",
+Sub(comp) comp.AssertNoDiagnostics())
+        End Sub
+
+        <Fact>
+        Public Sub RefAssemblyClient_EmitAllTypes()
+            VerifyRefAssemblyClient("
+Public Interface I1(Of T)
+End Interface
+Public Interface I2
+End Interface
+Public Class A
+    Implements I1(Of X)
+End Class
+Friend Class X
+    Implements I2
+End Class
+", "
+Public Class C
+    Public Function M(a As A) As I1(Of I2)
+        Return DirectCast(a, I1(Of I2))
+    End Function
+End Class
+",
+Sub(comp) comp.AssertNoDiagnostics())
+        End Sub
+
+        <Fact>
+        Public Sub RefAssemblyClient_StructWithPrivateGenericField()
+            VerifyRefAssemblyClient("
+Public Structure Container(Of T)
+    Private Dim contained As T
+End Structure
+", "
+Public Structure Usage
+    Public Dim x As Container(Of Usage)
+End Structure
+",
+Sub(comp)
+    comp.AssertTheseDiagnostics(<errors>
+BC30294: Structure 'Usage' cannot contain an instance of itself: 
+    'Usage' contains 'Container(Of Usage)' (variable 'x').
+    'Container(Of Usage)' contains 'Usage' (variable 'contained').
+    Public Dim x As Container(Of Usage)
+               ~
+                                </errors>)
+End Sub)
+        End Sub
+
+        <Fact>
+        Public Sub RefAssemblyClient_EmitAllVirtualMethods()
+            Dim comp1 = CreateVisualBasicCompilation("
+<assembly:System.Runtime.CompilerServices.InternalsVisibleTo(""VB2"")>
+<assembly:System.Runtime.CompilerServices.InternalsVisibleTo(""VB3"")>
+Public MustInherit Class C1
+    Friend Sub M()
+    End Sub
+End Class
+", assemblyName:="VB1", referencedAssemblies:={MscorlibRef})
+            comp1.AssertTheseDiagnostics()
+            Dim image1 = comp1.EmitToImageReference(EmitOptions.Default)
+
+            Dim comp2 = CreateVisualBasicCompilation("
+Public MustInherit Class C2
+    Inherits C1
+
+    Friend Overloads Sub M()
+    End Sub
+End Class
+", assemblyName:="VB2", referencedAssemblies:={MscorlibRef, image1})
+            comp2.AssertTheseDiagnostics()
+            Dim image2 = comp2.EmitToImageReference(EmitOptions.Default.WithEmitMetadataOnly(True).WithIncludePrivateMembers(False))
+
+            ' If internal virtual methods were not included in ref assemblies, then C3 could not be concrete
+
+            Dim comp3 = CreateVisualBasicCompilation("
+Public Class C3
+    Inherits C2
+End Class
+", assemblyName:="VB3", referencedAssemblies:={MscorlibRef, image1, image2})
+            comp3.AssertTheseDiagnostics()
+
+        End Sub
+
+        <Fact>
+        Public Sub RefAssemblyClient_StructWithPrivateIntField()
+            VerifyRefAssemblyClient("
+Public Structure S
+    Private Dim i As Integer
+End Structure
+", "
+Public Class C
+    Public Function M() As String
+        Dim s As S
+        Return s.ToString()
+    End Function
+End Class
+",
+Sub(comp) comp.AssertTheseDiagnostics())
+        End Sub
+
+        Private Sub VerifyRefAssemblyClient(lib_vb As String, client_vb As String, validator As Action(Of VisualBasicCompilation), Optional debugFlag As Integer = -1)
+            ' Whether the library is compiled in full, as metadata-only, or as a ref assembly should be transparent
+            ' to the client and the validator should be able to verify the same expectations.
+
+            If debugFlag = -1 OrElse debugFlag = 0 Then
+                VerifyRefAssemblyClient(lib_vb, client_vb, validator,
+                                        EmitOptions.Default.WithEmitMetadataOnly(False))
+            End If
+            If debugFlag = -1 OrElse debugFlag = 1 Then
+                VerifyRefAssemblyClient(lib_vb, client_vb, validator,
+                                        EmitOptions.Default.WithEmitMetadataOnly(True).WithIncludePrivateMembers(True))
+            End If
+            If debugFlag = -1 OrElse debugFlag = 2 Then
+                VerifyRefAssemblyClient(lib_vb, client_vb, validator,
+                                        EmitOptions.Default.WithEmitMetadataOnly(False).WithIncludePrivateMembers(False))
+            End If
+        End Sub
+
+        Private Sub VerifyRefAssemblyClient(lib_vb As String, source As String, validator As Action(Of VisualBasicCompilation), emitOptions As EmitOptions)
+            Dim name = GetUniqueName()
+            Dim libComp = CreateCompilationWithMscorlib({Parse(lib_vb)},
+                options:=TestOptions.DebugDll.WithDeterministic(True), assemblyName:=name)
+            Dim libImage = libComp.EmitToImageReference(emitOptions)
+
+            Dim comp = CreateCompilationWithMscorlib(source, references:={libImage}, options:=TestOptions.DebugDll)
+            validator(comp)
+        End Sub
+
         <Fact>
         Public Sub RefAssembly_IgnoresSomeDiagnostics()
 
@@ -415,33 +727,77 @@ End Class"
             Dim comp As Compilation = CreateCompilation(source, references:={MscorlibRef},
                             options:=TestOptions.DebugDll.WithDeterministic(True))
 
-            Dim emitRefOnly = EmitOptions.Default.WithEmitMetadataOnly(True)
+            Dim verifier = CompileAndVerify(comp, emitOptions:=EmitOptions.Default.WithEmitMetadataOnly(True), verify:=True)
+
+            ' verify metadata (types, members, attributes) of the regular assembly
+            Dim realImage = comp.EmitToImageReference(EmitOptions.Default)
+            Dim compWithReal = CreateCompilation("", references:={MscorlibRef, realImage},
+                            options:=TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All))
+            Dim realAssembly = compWithReal.SourceModule.GetReferencedAssemblySymbols().Last()
+            AssertEx.SetEqual(realAssembly.GlobalNamespace.GetMembers().Select(Function(m) m.ToDisplayString()),
+                {"<Module>", "PublicClass"})
+
+            AssertEx.SetEqual(
+                DirectCast(realAssembly.GlobalNamespace.GetMember("PublicClass"), NamedTypeSymbol).GetMembers().
+                                Select(Function(m) m.ToTestDisplayString()),
+                            {"Sub PublicClass.PublicMethod()", "Sub PublicClass.PrivateMethod()",
+                                "Sub PublicClass.InternalMethod()", "Sub PublicClass.ProtectedMethod()",
+                                "Sub PublicClass.AbstractMethod()", "Sub PublicClass..ctor()"})
+
+            AssertEx.SetEqual(realAssembly.GetAttributes().Select(Function(a) a.AttributeClass.ToTestDisplayString()),
+                {"System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
+                    "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
+                    "System.Diagnostics.DebuggableAttribute"})
 
-            Dim verifier = CompileAndVerify(comp, emitOptions:=emitRefOnly, verify:=True)
+            ' verify metadata (types, members, attributes) of the metadata-only assembly
+            Dim emitMetadataOnly = EmitOptions.Default.WithEmitMetadataOnly(True)
+            CompileAndVerify(comp, emitOptions:=emitMetadataOnly, verify:=True)
 
-            ' verify metadata (types, members, attributes)
-            Dim image = comp.EmitToImageReference(emitRefOnly)
-            Dim comp2 = CreateCompilation("", references:={MscorlibRef, image},
+            Dim metadataImage = comp.EmitToImageReference(emitMetadataOnly)
+            Dim compWithMetadata = CreateCompilation("", references:={MscorlibRef, metadataImage},
                             options:=TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All))
-            Dim assembly As AssemblySymbol = comp2.SourceModule.GetReferencedAssemblySymbols().Last()
-            Dim members = assembly.GlobalNamespace.GetMembers()
-            AssertEx.SetEqual(members.Select(Function(m) m.ToDisplayString()),
+            Dim metadataAssembly As AssemblySymbol = compWithMetadata.SourceModule.GetReferencedAssemblySymbols().Last()
+            AssertEx.SetEqual(metadataAssembly.GlobalNamespace.GetMembers().Select(Function(m) m.ToDisplayString()),
                 {"<Module>", "PublicClass"})
 
             AssertEx.SetEqual(
-                DirectCast(assembly.GlobalNamespace.GetMember("PublicClass"), NamedTypeSymbol).GetMembers().
+                DirectCast(metadataAssembly.GlobalNamespace.GetMember("PublicClass"), NamedTypeSymbol).GetMembers().
                                 Select(Function(m) m.ToTestDisplayString()),
                             {"Sub PublicClass.PublicMethod()", "Sub PublicClass.PrivateMethod()",
                                 "Sub PublicClass.InternalMethod()", "Sub PublicClass.ProtectedMethod()",
                                 "Sub PublicClass.AbstractMethod()", "Sub PublicClass..ctor()"})
 
-            AssertEx.SetEqual(assembly.GetAttributes().Select(Function(a) a.AttributeClass.ToTestDisplayString()),
+            AssertEx.SetEqual(metadataAssembly.GetAttributes().Select(Function(a) a.AttributeClass.ToTestDisplayString()),
                 {"System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
                     "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
                     "System.Diagnostics.DebuggableAttribute"})
 
-            Dim peImage = comp.EmitToArray(emitRefOnly)
-            MetadataReaderUtils.AssertEmptyOrThrowNull(peImage)
+            MetadataReaderUtils.AssertEmptyOrThrowNull(comp.EmitToArray(emitMetadataOnly))
+
+            ' verify metadata (types, members, attributes) of the metadata-only assembly
+            Dim emitRefOnly = EmitOptions.Default.WithEmitMetadataOnly(True).WithIncludePrivateMembers(False)
+            CompileAndVerify(comp, emitOptions:=emitRefOnly, verify:=True)
+
+            Dim refImage = comp.EmitToImageReference(emitRefOnly)
+            Dim compWithRef = CreateCompilation("", references:={MscorlibRef, refImage},
+                            options:=TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All))
+            Dim refAssembly As AssemblySymbol = compWithRef.SourceModule.GetReferencedAssemblySymbols().Last()
+            AssertEx.SetEqual(refAssembly.GlobalNamespace.GetMembers().Select(Function(m) m.ToDisplayString()),
+                {"<Module>", "PublicClass"})
+
+            AssertEx.SetEqual(
+                DirectCast(refAssembly.GlobalNamespace.GetMember("PublicClass"), NamedTypeSymbol).GetMembers().
+                                Select(Function(m) m.ToTestDisplayString()),
+                            {"Sub PublicClass..ctor()", "Sub PublicClass.PublicMethod()",
+                                "Sub PublicClass.ProtectedMethod()", "Sub PublicClass.AbstractMethod()"})
+
+            AssertEx.SetEqual(refAssembly.GetAttributes().Select(Function(a) a.AttributeClass.ToTestDisplayString()),
+                {"System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
+                    "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
+                    "System.Diagnostics.DebuggableAttribute",
+                    "System.Runtime.CompilerServices.ReferenceAssemblyAttribute"})
+
+            MetadataReaderUtils.AssertEmptyOrThrowNull(comp.EmitToArray(emitRefOnly))
         End Sub
 
         <Fact>
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.vb
index bdbaf61013e05..ca3e62666efee 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.vb
@@ -344,7 +344,7 @@ End Class
             Dim displayClass = peAssemblyBuilder.GetSynthesizedTypes(c).Single()
             Assert.Equal("_Closure$__1-0", displayClass.Name)
 
-            Dim emitContext = New EmitContext(peAssemblyBuilder, Nothing, New DiagnosticBag())
+            Dim emitContext = New EmitContext(peAssemblyBuilder, Nothing, New DiagnosticBag(), metadataOnly:=False, includePrivateMembers:=True)
 
             Dim fields = displayClass.GetFields(emitContext).ToArray()
             Dim x1 = fields(0)
@@ -415,7 +415,7 @@ End Class
             Dim displayClass = peAssemblyBuilder.GetSynthesizedTypes(c).Single()
             Assert.Equal("_Closure$__1-0", displayClass.Name)
 
-            Dim emitContext = New EmitContext(peAssemblyBuilder, Nothing, New DiagnosticBag())
+            Dim emitContext = New EmitContext(peAssemblyBuilder, Nothing, New DiagnosticBag(), metadataOnly:=False, includePrivateMembers:=True)
 
             Dim fields = displayClass.GetFields(emitContext).ToArray()
             Dim x1 = fields(0)
@@ -492,7 +492,7 @@ End Class
             Assert.Equal("_Closure$__1-0", displayClasses(0).Name)
             Assert.Equal("_Closure$__", displayClasses(1).Name)
 
-            Dim emitContext = New EmitContext(peAssemblyBuilder, Nothing, New DiagnosticBag())
+            Dim emitContext = New EmitContext(peAssemblyBuilder, Nothing, New DiagnosticBag(), metadataOnly:=False, includePrivateMembers:=True)
 
             Dim fields = displayClasses(0).GetFields(emitContext).ToArray()
             Dim x1 = fields(0)
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/PropertyTests.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/PropertyTests.vb
index c6a5b40bf4a6f..b82c94c69f06c 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/PropertyTests.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/PropertyTests.vb
@@ -8143,7 +8143,7 @@ End Class
             Dim typeDef = DirectCast([class], Cci.ITypeDefinition)
             Dim [module] = New PEAssemblyBuilder(DirectCast([class].ContainingAssembly, SourceAssemblySymbol), EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary, GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable(Of ResourceDescription)())
 
-            Dim context = New EmitContext([module], Nothing, New DiagnosticBag())
+            Dim context = New EmitContext([module], Nothing, New DiagnosticBag(), metadataOnly:=False, includePrivateMembers:=True)
             Dim explicitOverrides = typeDef.GetExplicitImplementationOverrides(context)
             Assert.Equal(2, explicitOverrides.Count())
             Assert.True(explicitOverrides.All(Function(override) [class] Is override.ContainingType))
diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs
index d8242652582ab..9d20afd45c659 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/EvaluationContext.cs
@@ -258,7 +258,7 @@ internal byte[] CompileExpressions(
                     using (var stream = new MemoryStream())
                     {
                         Cci.PeWriter.WritePeToStream(
-                            new EmitContext(moduleBuilder, null, diagnostics),
+                            new EmitContext(moduleBuilder, null, diagnostics, metadataOnly: false, includePrivateMembers: true),
                             context.MessageProvider,
                             () => stream,
                             getPortablePdbStreamOpt: null,
@@ -266,6 +266,7 @@ internal byte[] CompileExpressions(
                             pdbPathOpt: null,
                             metadataOnly: false,
                             isDeterministic: false,
+                            emitTestCoverageData: false,
                             cancellationToken: default(CancellationToken));
                         if (!diagnostics.HasAnyErrors())
                         {
@@ -319,7 +320,7 @@ internal override CompileResult CompileExpression(
             using (var stream = new MemoryStream())
             {
                 Cci.PeWriter.WritePeToStream(
-                    new EmitContext(moduleBuilder, null, diagnostics),
+                    new EmitContext(moduleBuilder, null, diagnostics, metadataOnly: false, includePrivateMembers: true),
                     context.MessageProvider,
                     () => stream,
                     getPortablePdbStreamOpt: null,
@@ -327,6 +328,7 @@ internal override CompileResult CompileExpression(
                     pdbPathOpt: null,
                     metadataOnly: false,
                     isDeterministic: false,
+                    emitTestCoverageData: false,
                     cancellationToken: default(CancellationToken));
 
                 if (diagnostics.HasAnyErrors())
@@ -403,7 +405,7 @@ internal override CompileResult CompileAssignment(
             using (var stream = new MemoryStream())
             {
                 Cci.PeWriter.WritePeToStream(
-                    new EmitContext(moduleBuilder, null, diagnostics),
+                    new EmitContext(moduleBuilder, null, diagnostics, metadataOnly: false, includePrivateMembers: true),
                     context.MessageProvider,
                     () => stream,
                     getPortablePdbStreamOpt: null,
@@ -411,6 +413,7 @@ internal override CompileResult CompileAssignment(
                     pdbPathOpt: null,
                     metadataOnly: false,
                     isDeterministic: false,
+                    emitTestCoverageData: false,
                     cancellationToken: default(CancellationToken));
 
                 if (diagnostics.HasAnyErrors())
@@ -450,7 +453,7 @@ internal override ReadOnlyCollection<byte> CompileGetLocals(
                 using (var stream = new MemoryStream())
                 {
                     Cci.PeWriter.WritePeToStream(
-                        new EmitContext(moduleBuilder, null, diagnostics),
+                        new EmitContext(moduleBuilder, null, diagnostics, metadataOnly: false, includePrivateMembers: true),
                         context.MessageProvider,
                         () => stream,
                         getPortablePdbStreamOpt: null,
@@ -458,6 +461,7 @@ internal override ReadOnlyCollection<byte> CompileGetLocals(
                         pdbPathOpt: null,
                         metadataOnly: false,
                         isDeterministic: false,
+                        emitTestCoverageData: false,
                         cancellationToken: default(CancellationToken));
 
                     if (!diagnostics.HasAnyErrors())
diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ReferencedModulesTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ReferencedModulesTests.cs
index 8707ca2bfaea8..0a151ad44936e 100644
--- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ReferencedModulesTests.cs
+++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ReferencedModulesTests.cs
@@ -755,7 +755,7 @@ public class Void : Object { }
             ExpressionCompilerTestHelpers.EmitCorLibWithAssemblyReferences(
                 compCorLib,
                 null,
-                moduleBuilder => new PEAssemblyBuilderWithAdditionalReferences(moduleBuilder, objectType),
+                (moduleBuilder, emitOptions) => new PEAssemblyBuilderWithAdditionalReferences(moduleBuilder, emitOptions, objectType),
                 out peBytes,
                 out pdbBytes);
 
@@ -874,7 +874,7 @@ public class Void : Object { }
             ExpressionCompilerTestHelpers.EmitCorLibWithAssemblyReferences(
                 compCorLib,
                 pdbPath,
-                moduleBuilder => new PEAssemblyBuilderWithAdditionalReferences(moduleBuilder, objectType),
+                (moduleBuilder, emitOptions) => new PEAssemblyBuilderWithAdditionalReferences(moduleBuilder, emitOptions, objectType),
                 out peBytes,
                 out pdbBytes);
             var symReader = SymReaderFactory.CreateReader(pdbBytes);
@@ -994,8 +994,8 @@ private sealed class PEAssemblyBuilderWithAdditionalReferences : PEModuleBuilder
             private readonly CommonPEModuleBuilder _builder;
             private readonly NamespaceTypeDefinitionNoBase _objectType;
 
-            internal PEAssemblyBuilderWithAdditionalReferences(CommonPEModuleBuilder builder, INamespaceTypeDefinition objectType) :
-                base((SourceModuleSymbol)builder.CommonSourceModule, builder.EmitOptions, builder.OutputKind, builder.SerializationProperties, builder.ManifestResources)
+            internal PEAssemblyBuilderWithAdditionalReferences(CommonPEModuleBuilder builder, EmitOptions emitOptions, INamespaceTypeDefinition objectType) :
+                base((SourceModuleSymbol)builder.CommonSourceModule, emitOptions, builder.OutputKind, builder.SerializationProperties, builder.ManifestResources)
             {
                 _builder = builder;
                 _objectType = new NamespaceTypeDefinitionNoBase(objectType);
diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/TupleTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/TupleTests.cs
index d3cbea65c3dd7..e329be81b7379 100644
--- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/TupleTests.cs
+++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/TupleTests.cs
@@ -133,9 +133,9 @@ public struct ValueTuple<T1, T2>
                 AssertEx.SetEqual(new[] { "corlib 2.0", appRef + " 0.0" }, reader.DumpAssemblyReferences());
 
                 AssertEx.SetEqual(new[] {
-                        "Object, System, AssemblyRef:corlib",
-                        "ValueTuple`2, System, AssemblyRef:" + appRef, // ValueTuple comes from app, not corlib
-                        ", System, AssemblyRef:" + appRef },
+                        "Object, System, AssemblyReference:corlib",
+                        "ValueTuple`2, System, AssemblyReference:" + appRef, // ValueTuple comes from app, not corlib
+                        ", System, AssemblyReference:" + appRef },
                     reader.DumpTypeReferences());
             }
         }
diff --git a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs
index 89f2f4c3f640a..816cb5c64ae04 100644
--- a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs
+++ b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs
@@ -756,7 +756,7 @@ internal unsafe static MetadataReader ToMetadataReader(this PEMemoryBlock metada
         internal static void EmitCorLibWithAssemblyReferences(
             Compilation comp,
             string pdbPath,
-            Func<CommonPEModuleBuilder, CommonPEModuleBuilder> getModuleBuilder,
+            Func<CommonPEModuleBuilder, EmitOptions, CommonPEModuleBuilder> getModuleBuilder,
             out ImmutableArray<byte> peBytes,
             out ImmutableArray<byte> pdbBytes)
         {
@@ -774,7 +774,7 @@ internal static void EmitCorLibWithAssemblyReferences(
 
             // Wrap the module builder in a module builder that
             // reports the "System.Object" type as having no base type.
-            moduleBuilder = getModuleBuilder(moduleBuilder);
+            moduleBuilder = getModuleBuilder(moduleBuilder, emitOptions);
             bool result = comp.Compile(
                 moduleBuilder,
                 emittingPdb: pdbPath != null,
@@ -787,13 +787,14 @@ internal static void EmitCorLibWithAssemblyReferences(
                 using (var pdbStream = new MemoryStream())
                 {
                     PeWriter.WritePeToStream(
-                        new EmitContext(moduleBuilder, null, diagnostics),
+                        new EmitContext(moduleBuilder, null, diagnostics, metadataOnly: false, includePrivateMembers: true),
                         comp.MessageProvider,
                         () => peStream,
                         () => pdbStream,
                         null, null,
                         metadataOnly: true,
                         isDeterministic: false,
+                        emitTestCoverageData: false,
                         cancellationToken: default(CancellationToken));
 
                     peBytes = peStream.ToImmutable();
diff --git a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/NamespaceTypeDefinitionNoBase.cs b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/NamespaceTypeDefinitionNoBase.cs
index 3349f6420f9a6..4fe32d18b0a5e 100644
--- a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/NamespaceTypeDefinitionNoBase.cs
+++ b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/NamespaceTypeDefinitionNoBase.cs
@@ -31,7 +31,7 @@ internal NamespaceTypeDefinitionNoBase(INamespaceTypeDefinition underlyingType)
 
         ISpecializedNestedTypeReference ITypeReference.AsSpecializedNestedTypeReference => UnderlyingType.AsSpecializedNestedTypeReference;
 
-        IEnumerable<IEventDefinition> ITypeDefinition.Events => UnderlyingType.Events;
+        IEnumerable<IEventDefinition> ITypeDefinition.GetEvents(EmitContext context) => UnderlyingType.GetEvents(context);
 
         ushort INamedTypeReference.GenericParameterCount => 0;
 
diff --git a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/EvaluationContext.vb b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/EvaluationContext.vb
index 39420a5649510..2096308f5bdd8 100644
--- a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/EvaluationContext.vb
+++ b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/EvaluationContext.vb
@@ -392,7 +392,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
 
             Using stream As New MemoryStream()
                 Cci.PeWriter.WritePeToStream(
-                        New EmitContext(moduleBuilder, Nothing, diagnostics),
+                        New EmitContext(moduleBuilder, Nothing, diagnostics, metadataOnly:=False, includePrivateMembers:=True),
                         context.MessageProvider,
                         Function() stream,
                         getPortablePdbStreamOpt:=Nothing,
@@ -400,6 +400,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
                         pdbPathOpt:=Nothing,
                         metadataOnly:=False,
                         isDeterministic:=False,
+                        emitTestCoverageData:=False,
                         cancellationToken:=Nothing)
 
                 If diagnostics.HasAnyErrors() Then
@@ -439,7 +440,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
 
             Using stream As New MemoryStream()
                 Cci.PeWriter.WritePeToStream(
-                        New EmitContext(modulebuilder, Nothing, diagnostics),
+                        New EmitContext(modulebuilder, Nothing, diagnostics, metadataOnly:=False, includePrivateMembers:=True),
                         context.MessageProvider,
                         Function() stream,
                         getPortablePdbStreamOpt:=Nothing,
@@ -447,6 +448,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
                         pdbPathOpt:=Nothing,
                         metadataOnly:=False,
                         isDeterministic:=False,
+                        emitTestCoverageData:=False,
                         cancellationToken:=Nothing)
 
                 If diagnostics.HasAnyErrors() Then
@@ -487,7 +489,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
             If modulebuilder IsNot Nothing AndAlso locals.Count > 0 Then
                 Using stream As New MemoryStream()
                     Cci.PeWriter.WritePeToStream(
-                        New EmitContext(modulebuilder, Nothing, diagnostics),
+                        New EmitContext(modulebuilder, Nothing, diagnostics, metadataOnly:=False, includePrivateMembers:=True),
                         context.MessageProvider,
                         Function() stream,
                         getPortablePdbStreamOpt:=Nothing,
@@ -495,6 +497,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
                         pdbPathOpt:=Nothing,
                         metadataOnly:=False,
                         isDeterministic:=False,
+                        emitTestCoverageData:=False,
                         cancellationToken:=Nothing)
 
                     If Not diagnostics.HasAnyErrors() Then
diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ReferencedModulesTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ReferencedModulesTests.vb
index 6c823b7032cf5..9bb2dd66ed01c 100644
--- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ReferencedModulesTests.vb
+++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/ReferencedModulesTests.vb
@@ -491,7 +491,7 @@ End Namespace"
             ExpressionCompilerTestHelpers.EmitCorLibWithAssemblyReferences(
                 compCorLib,
                 Nothing,
-                Function(moduleBuilder) New PEAssemblyBuilderWithAdditionalReferences(moduleBuilder, objectType),
+                Function(moduleBuilder, emitOptions) New PEAssemblyBuilderWithAdditionalReferences(moduleBuilder, emitOptions, objectType),
                 peBytes,
                 pdbBytes)
 
@@ -595,8 +595,8 @@ End Class"
             Private ReadOnly _builder As CommonPEModuleBuilder
             Private ReadOnly _objectType As NamespaceTypeDefinitionNoBase
 
-            Friend Sub New(builder As CommonPEModuleBuilder, objectType As INamespaceTypeDefinition)
-                MyBase.New(DirectCast(builder.CommonSourceModule, SourceModuleSymbol), builder.EmitOptions, builder.OutputKind, builder.SerializationProperties, builder.ManifestResources)
+            Friend Sub New(builder As CommonPEModuleBuilder, emitOptions As EmitOptions, objectType As INamespaceTypeDefinition)
+                MyBase.New(DirectCast(builder.CommonSourceModule, SourceModuleSymbol), emitOptions, builder.OutputKind, builder.SerializationProperties, builder.ManifestResources)
 
                 _builder = builder
                 _objectType = New NamespaceTypeDefinitionNoBase(objectType)
diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/TupleTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/TupleTests.vb
index 300405b68fd12..9405e8870e5fe 100644
--- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/TupleTests.vb
+++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/TupleTests.vb
@@ -142,9 +142,9 @@ End Class"
                 Dim appRef = app.Assembly.Identity.Name
                 AssertEx.SetEqual({"corlib 2.0", appRef + " 0.0"}, reader.DumpAssemblyReferences())
 
-                AssertEx.SetEqual({"Object, System, AssemblyRef:corlib",
-                    "ValueTuple`2, System, AssemblyRef:" + appRef, ' ValueTuple comes from app, not corlib
-                    ", System, AssemblyRef:" + appRef},
+                AssertEx.SetEqual({"Object, System, AssemblyReference:corlib",
+                    "ValueTuple`2, System, AssemblyReference:" + appRef, ' ValueTuple comes from app, not corlib
+                    ", System, AssemblyReference:" + appRef},
                     reader.DumpTypeReferences())
             End Using
         End Sub
diff --git a/src/Test/Utilities/Portable/Metadata/MetadataReaderUtils.cs b/src/Test/Utilities/Portable/Metadata/MetadataReaderUtils.cs
index f5d30937337f8..124a802cec856 100644
--- a/src/Test/Utilities/Portable/Metadata/MetadataReaderUtils.cs
+++ b/src/Test/Utilities/Portable/Metadata/MetadataReaderUtils.cs
@@ -260,22 +260,52 @@ public static IEnumerable<string> DumpTypeReferences(this MetadataReader reader)
         }
 
         public static string Dump(this MetadataReader reader, EntityHandle handle)
+        {
+            string value = DumpRec(reader, handle);
+            string kind = handle.Kind.ToString();
+            if (value != null)
+            {
+                return $"{kind}:{value}";
+            }
+            else
+            {
+                return kind;
+            }
+        }
+
+        private static string DumpRec(this MetadataReader reader, EntityHandle handle)
         {
             switch (handle.Kind)
             {
                 case HandleKind.AssemblyReference:
-                    return "AssemblyRef:" + reader.GetString(reader.GetAssemblyReference((AssemblyReferenceHandle)handle).Name);
+                    return reader.GetString(reader.GetAssemblyReference((AssemblyReferenceHandle)handle).Name);
                 case HandleKind.TypeDefinition:
-                    return "TypeDef:" + reader.GetString(reader.GetTypeDefinition((TypeDefinitionHandle)handle).Name);
+                    return reader.GetString(reader.GetTypeDefinition((TypeDefinitionHandle)handle).Name);
                 case HandleKind.MethodDefinition:
-                    var method = reader.GetMethodDefinition((MethodDefinitionHandle)handle);
-                    var blob = reader.GetBlobReader(method.Signature);
-                    var decoder = new SignatureDecoder<string, object>(ConstantSignatureVisualizer.Instance, reader, genericContext: null);
-                    var signature =  decoder.DecodeMethodSignature(ref blob);
-                    var parameters = signature.ParameterTypes.Join(", ");
-                    return $"MethodDef: {signature.ReturnType} {reader.GetString(method.Name)}({parameters})";
+                    {
+                        var method = reader.GetMethodDefinition((MethodDefinitionHandle)handle);
+                        var blob = reader.GetBlobReader(method.Signature);
+                        var decoder = new SignatureDecoder<string, object>(ConstantSignatureVisualizer.Instance, reader, genericContext: null);
+                        var signature = decoder.DecodeMethodSignature(ref blob);
+                        var parameters = signature.ParameterTypes.Join(", ");
+                        return $"{signature.ReturnType} {reader.GetString(method.Name)}({parameters})";
+                    }
+                case HandleKind.MemberReference:
+                    {
+                        var member = reader.GetMemberReference((MemberReferenceHandle)handle);
+                        var blob = reader.GetBlobReader(member.Signature);
+                        var decoder = new SignatureDecoder<string, object>(ConstantSignatureVisualizer.Instance, reader, genericContext: null);
+                        var signature = decoder.DecodeMethodSignature(ref blob);
+                        var parameters = signature.ParameterTypes.Join(", ");
+                        return $"{signature.ReturnType} {DumpRec(reader, member.Parent)}{reader.GetString(member.Name)}({parameters})";
+                    }
+                case HandleKind.TypeReference:
+                    {
+                        var type = reader.GetTypeReference((TypeReferenceHandle)handle);
+                        return $"{reader.GetString(type.Namespace)}.{reader.GetString(type.Name)}";
+                    }
                 default:
-                    return handle.Kind.ToString();
+                    return null;
             }
         }
 

From 5a259513a9bae12676ed5009c9d26b2d91c33ce2 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Thu, 13 Apr 2017 14:17:49 -0700
Subject: [PATCH 012/284] Filter "missing method body" error when emitting
 metadata-only (#18542)

---
 .../Portable/Compilation/CSharpCompilation.cs |  9 ++++-
 .../Test/Emit/Emit/CompilationEmitTests.cs    | 35 +++++++++++++------
 .../Core/Portable/Compilation/Compilation.cs  |  9 +++--
 .../Compilation/VisualBasicCompilation.vb     |  2 +-
 4 files changed, 40 insertions(+), 15 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index fe5d5899819ad..915ff1af34987 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
@@ -2311,7 +2311,14 @@ internal override bool CompileMethods(
         {
             // The diagnostics should include syntax and declaration errors. We insert these before calling Emitter.Emit, so that the emitter
             // does not attempt to emit if there are declaration errors (but we do insert all errors from method body binding...)
-            bool hasDeclarationErrors = !FilterAndAppendDiagnostics(diagnostics, GetDiagnostics(CompilationStage.Declare, true, cancellationToken));
+            PooledHashSet<int> excludeDiagnostics = null;
+            if (emitMetadataOnly)
+            {
+                excludeDiagnostics = PooledHashSet<int>.GetInstance();
+                excludeDiagnostics.Add((int)ErrorCode.ERR_ConcreteMissingBody);
+            }
+            bool hasDeclarationErrors = !FilterAndAppendDiagnostics(diagnostics, GetDiagnostics(CompilationStage.Declare, true, cancellationToken), excludeDiagnostics);
+            excludeDiagnostics?.Free();
 
             // TODO (tomat): NoPIA:
             // EmbeddedSymbolManager.MarkAllDeferredSymbolsAsReferenced(this)
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
index 69dc56b4444cd..22295584ff9bb 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
@@ -321,7 +321,6 @@ public void RefAssembly_ReferenceAssemblyAttributeAlsoInSource()
         [InlineData("public struct S { private int i; }", "public struct S { }", Match.Different)]
         [InlineData("private int i;", "", Match.RefOut)]
         [InlineData("public C() { }", "", Match.BothMetadataAndRefOut)]
-        //[InlineData("public int NoBody();", "public int NoBody() { }", Match.BothMetadataAndRefOut)] // PROTOTYPE(refout) Further refinement https://github.com/dotnet/roslyn/issues/17612
         public void RefAssembly_InvariantToSomeChanges(string left, string right, Match expectedMatch)
         {
             string sourceTemplate = @"
@@ -569,26 +568,40 @@ private static void VerifyRefAssemblyClient(string lib_cs, string source, Action
 
         [Theory]
         [InlineData("public int M() { error(); }", true)]
-        [InlineData("public int M() { error() }", false)] // Should be true. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
+        [InlineData("public int M() { error() }", false)] // This may get relaxed. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
+        [InlineData("public int M();", true)]
+        [InlineData("public int M() { int Local(); }", true)]
+        [InlineData("public C();", true)]
+        [InlineData("~ C();", true)]
         [InlineData("public Error M() { return null; }", false)] // This may get relaxed. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
+        [InlineData("public static explicit operator C(int i);", true)]
+        [InlineData("public async Task M();", false)]
+        [InlineData("partial void M(); partial void M();", false)] // This may get relaxed. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
         public void RefAssembly_IgnoresSomeDiagnostics(string change, bool expectSuccess)
         {
             string sourceTemplate = @"
-public class C
+using System.Threading.Tasks;
+public partial class C
 {
     CHANGE
 }
 ";
-            string source = sourceTemplate.Replace("CHANGE", change);
-            string name = GetUniqueName();
-            CSharpCompilation comp1 = CreateCompilationWithMscorlib(Parse(source),
-                options: TestOptions.DebugDll.WithDeterministic(true), assemblyName: name);
+            VerifyIgnoresDiagnostics(EmitOptions.Default.WithEmitMetadataOnly(false).WithTolerateErrors(false), success: false);
+            VerifyIgnoresDiagnostics(EmitOptions.Default.WithEmitMetadataOnly(true).WithTolerateErrors(false), success: expectSuccess);
 
-            using (var output = new MemoryStream())
+            void VerifyIgnoresDiagnostics(EmitOptions emitOptions, bool success)
             {
-                var emitResult = comp1.Emit(output, options: EmitOptions.Default.WithEmitMetadataOnly(true));
-                Assert.Equal(expectSuccess, emitResult.Success);
-                Assert.Equal(!expectSuccess, emitResult.Diagnostics.Any());
+                string source = sourceTemplate.Replace("CHANGE", change);
+                string name = GetUniqueName();
+                CSharpCompilation comp = CreateCompilationWithMscorlib(Parse(source),
+                    options: TestOptions.DebugDll.WithDeterministic(true), assemblyName: name);
+
+                using (var output = new MemoryStream())
+                {
+                    var emitResult = comp.Emit(output, options: emitOptions);
+                    Assert.Equal(!success, emitResult.Diagnostics.HasAnyErrors());
+                    Assert.Equal(success, emitResult.Success);
+                }
             }
         }
 
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index a550001f4e3d2..d1d232aa1fafc 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -1151,7 +1151,7 @@ internal void CompleteCompilationEventQueue_NoLock()
         /// <returns>True if there were no errors or warnings-as-errors.</returns>
         internal bool FilterAndAppendAndFreeDiagnostics(DiagnosticBag accumulator, ref DiagnosticBag incoming)
         {
-            bool result = FilterAndAppendDiagnostics(accumulator, incoming.AsEnumerableWithoutResolution());
+            bool result = FilterAndAppendDiagnostics(accumulator, incoming.AsEnumerableWithoutResolution(), exclude: null);
             incoming.Free();
             incoming = null;
             return result;
@@ -1161,13 +1161,18 @@ internal bool FilterAndAppendAndFreeDiagnostics(DiagnosticBag accumulator, ref D
         /// Filter out warnings based on the compiler options (/nowarn, /warn and /warnaserror) and the pragma warning directives.
         /// </summary>
         /// <returns>True when there is no error.</returns>
-        internal bool FilterAndAppendDiagnostics(DiagnosticBag accumulator, IEnumerable<Diagnostic> incoming)
+        internal bool FilterAndAppendDiagnostics(DiagnosticBag accumulator, IEnumerable<Diagnostic> incoming, HashSet<int> exclude)
         {
             bool hasError = false;
             bool reportSuppressedDiagnostics = Options.ReportSuppressedDiagnostics;
 
             foreach (Diagnostic d in incoming)
             {
+                if (exclude?.Contains(d.Code) == true)
+                {
+                    continue;
+                }
+
                 var filtered = Options.FilterDiagnostic(d);
                 if (filtered == null ||
                     (!reportSuppressedDiagnostics && filtered.IsSuppressed))
diff --git a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
index bbb44f49d5c2b..a0b37688456ff 100644
--- a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
+++ b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
@@ -2221,7 +2221,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
             ' The diagnostics should include syntax and declaration errors. We insert these before calling Emitter.Emit, so that we don't emit
             ' metadata if there are declaration errors or method body errors (but we do insert all errors from method body binding...)
-            Dim hasDeclarationErrors = Not FilterAndAppendDiagnostics(diagnostics, GetDiagnostics(CompilationStage.Declare, True, cancellationToken))
+            Dim hasDeclarationErrors = Not FilterAndAppendDiagnostics(diagnostics, GetDiagnostics(CompilationStage.Declare, True, cancellationToken), exclude:=Nothing)
 
             Dim moduleBeingBuilt = DirectCast(moduleBuilder, PEModuleBuilder)
 

From 80e794ea297c14ae0a371b47d92e0b3ad6f1bcf7 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Fri, 14 Apr 2017 13:00:52 -0700
Subject: [PATCH 013/284] Fix refout crash with GetEntryPoint when Main is
 private (#18696)

---
 .../Test/Emit/Emit/CompilationEmitTests.cs    | 52 +++++++++++++++++++
 .../Core/Portable/PEWriter/MetadataWriter.cs  |  2 +-
 2 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
index 22295584ff9bb..05613e9f0c4f3 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
@@ -238,6 +238,58 @@ public static void Main()
             }
         }
 
+        [Fact]
+        public void EmitRefAssemblyPrivateMain()
+        {
+            CSharpCompilation comp = CreateCompilationWithMscorlib(@"
+public class C
+{
+    internal static void Main()
+    {
+        System.Console.WriteLine(""hello"");
+    }
+}
+", options: TestOptions.DebugExe);
+
+            using (var output = new MemoryStream())
+            using (var metadataOutput = new MemoryStream())
+            {
+                // Previously, this would crash when trying to get the entry point for the ref assembly
+                // (but the Main method is not emitted in the ref assembly...)
+                EmitResult emitResult = comp.Emit(output, metadataPEStream: metadataOutput,
+                    options: new EmitOptions(includePrivateMembers: false));
+                Assert.True(emitResult.Success);
+                emitResult.Diagnostics.Verify();
+
+                VerifyEntryPoint(output, expectZero: false);
+                VerifyMethods(output, new[] { "void C.Main()", "C..ctor()" });
+
+                VerifyEntryPoint(metadataOutput, expectZero: true);
+                VerifyMethods(metadataOutput, new[] { "C..ctor()" });
+            }
+
+            void VerifyEntryPoint(MemoryStream stream, bool expectZero)
+            {
+                stream.Position = 0;
+                int entryPoint = new PEHeaders(stream).CorHeader.EntryPointTokenOrRelativeVirtualAddress;
+                Assert.Equal(expectZero, entryPoint == 0);
+            }
+
+            void VerifyMethods(MemoryStream stream, string[] expectedMethods)
+            {
+                stream.Position = 0;
+                var metadataRef = AssemblyMetadata.CreateFromImage(stream.ToArray()).GetReference();
+
+                var compWithMetadata = CreateCompilation("", references: new[] { MscorlibRef, metadataRef },
+                    options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
+
+                AssertEx.Equal(
+                    expectedMethods,
+                    ((NamedTypeSymbol)compWithMetadata.SourceModule.GetReferencedAssemblySymbols().Last()
+                        .GlobalNamespace.GetMember("C")).GetMembers().Select(m => m.ToTestDisplayString()));
+            }
+        }
+
         [Fact]
         public void RefAssembly_HasReferenceAssemblyAttribute()
         {
diff --git a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
index 930a5c7d8cdec..8c910f748deaf 100644
--- a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
@@ -1846,7 +1846,7 @@ public PortablePdbBuilder GetPortablePdbBuilder(ImmutableArray<int> typeSystemRo
 
         internal void GetEntryPoints(out MethodDefinitionHandle entryPointHandle, out MethodDefinitionHandle debugEntryPointHandle)
         {
-            if (IsFullMetadata)
+            if (IsFullMetadata && !MetadataOnly)
             {
                 // PE entry point is set for executable programs
                 IMethodReference entryPoint = module.PEEntryPoint;

From 4060bb346dc0cd9eb31cce1a0886673afe65d49d Mon Sep 17 00:00:00 2001
From: Ty Overby <ty@pre-alpha.com>
Date: Fri, 14 Apr 2017 13:47:42 -0700
Subject: [PATCH 014/284] Async main doc (#18081)

* Add markdown feature documents

* Update testing plan
---
 docs/features/async-main.md      | 12 +++++++
 docs/features/async-main.test.md | 56 ++++++++++++++++++++++++++++++++
 2 files changed, 68 insertions(+)
 create mode 100644 docs/features/async-main.md
 create mode 100644 docs/features/async-main.test.md

diff --git a/docs/features/async-main.md b/docs/features/async-main.md
new file mode 100644
index 0000000000000..b98068cd8c603
--- /dev/null
+++ b/docs/features/async-main.md
@@ -0,0 +1,12 @@
+# Async Task Main
+## [dotnet/csharplang proposal](https://github.com/dotnet/csharplang/blob/master/proposals/async-main.md)
+
+## Technical Details
+
+* The compiler must recognize `Task` and `Task<int>` as valid entrypoint return types in addition to `void` and `int`.
+* The compiler must allow `async` to be placed on a main method that returns a `Task` or a `Task<T>` (but not void).
+* The compiler must generate a shim method `$EntrypointMain` that mimics the arguments of the user-defined main.
+  * `static async Task Main(...)` -> `static void $EntrypointMain(...)`
+  * `static async Task<int> Main(...)` -> `static int $EntrypointMain(...)`
+  * The parameters between the user-defined main and the generated main should match exactly.
+* The body of the generated main should be `return Main(args...).GetAwaiter().GetResult();`
\ No newline at end of file
diff --git a/docs/features/async-main.test.md b/docs/features/async-main.test.md
new file mode 100644
index 0000000000000..9901e16e0bc3e
--- /dev/null
+++ b/docs/features/async-main.test.md
@@ -0,0 +1,56 @@
+Main areas to test:
+* Signature acceptance / rejection
+* Method body creation
+
+# Signature acceptance / rejection
+
+## Single Mains
+Classes that contain only a single "main" method
+
+### Single legal main
+* Past: Ok
+* New 7: Ok
+* New 7.1 Ok
+
+### Single async (void) main
+* Past: ERR (Async can't be main)
+* New 7: ERR (Update to get this to work)
+* New 7.1: Ok
+
+### Single async (Task) main
+* Past: ERR (No entrypoints found), WARN (has the wrong signature to be an entry point)
+* New 7: ERR (Update to get this to work)
+* New 7.1 Ok
+
+### Single async (Task<int>) main
+* Past: ERR (No entrypoints found), WARN (has the wrong signature)
+* New 7: ERR (Update to get this to work)
+* New 7.1: Ok
+
+## Multiple Mains
+Classes that contain more than one main
+
+### Multiple legal mains
+* Past: Err
+* New 7: Err
+* New 7.1: Err
+
+### Single legal main, single async (void) main
+* Past: Err (an entrypoint cannot be marked with async)
+* New 7: Err (new error here?)
+* New 7.1: Err (new error here? "void is not an acceptable async return type")
+
+### Single legal main, single legal Task main
+* Past: Ok (warning: task main has wrong signature)
+* New 7: Ok (new warning here)
+* New 7.1: Ok (new warning here?)
+
+### Single legal main, single legal Task<int> main
+* Past: Ok (warning: task main has wrong signature)
+* New 7: Ok (new warning here)
+* New 7.1: Ok (new warning here?)
+
+# Method body creation
+
+* Inspect IL for correct codegen.
+* Make sure that attributes are correctly applied to the synthesized mains.

From 306ca441920f60fb2051d12250e55b53131553c4 Mon Sep 17 00:00:00 2001
From: Ty Overby <ty@pre-alpha.com>
Date: Fri, 14 Apr 2017 15:32:16 -0700
Subject: [PATCH 015/284] Update async-main.test.md

---
 docs/features/async-main.test.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/docs/features/async-main.test.md b/docs/features/async-main.test.md
index 9901e16e0bc3e..4fc7de5c129fc 100644
--- a/docs/features/async-main.test.md
+++ b/docs/features/async-main.test.md
@@ -54,3 +54,17 @@ Classes that contain more than one main
 
 * Inspect IL for correct codegen.
 * Make sure that attributes are correctly applied to the synthesized mains.
+
+## Broken methods on Task and Task<T>
+
+* GetAwatier or GetResult are missing
+* GetAwaiter or GetResult don't have the required signature
+* Has the right shape, but types are missing
+
+## Task or Task<T> is missing
+
+This will be caught during entrypoint detection, should be a binding error.
+
+## Void or int is missing
+
+If Task can be found, but void or int can't be found, then the compiler should behave gracefully. 

From 1f68c4e7a9e9b2fa5305c71530d1428a1db7fa5a Mon Sep 17 00:00:00 2001
From: Ty Overby <ty@pre-alpha.com>
Date: Tue, 18 Apr 2017 10:39:04 -0700
Subject: [PATCH 016/284] Update async-main.test.md

---
 docs/features/async-main.test.md | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/docs/features/async-main.test.md b/docs/features/async-main.test.md
index 4fc7de5c129fc..9b4a51467e559 100644
--- a/docs/features/async-main.test.md
+++ b/docs/features/async-main.test.md
@@ -68,3 +68,32 @@ This will be caught during entrypoint detection, should be a binding error.
 ## Void or int is missing
 
 If Task can be found, but void or int can't be found, then the compiler should behave gracefully. 
+
+# Vlad Test Plan
+
+## Public interface of compiler APIs
+  -N/A?
+ 
+## General functionality
+- `Task` and `Task<int>` returns are allowed. Do we require `async`.
+- Multiple valid/invalid async candidates.
+- process exit code on success (void and int) and on exception
+- `/main:<type>` cmd switch is still functional
+ 
+## Old versions, compat
+- langver
+- when both async and regular Main avaialble. With old/new compiler versions.
+- async void Main. With old.new langver. With another applicable Main present.
+ 
+## Type and members
+- Access modifiers (public, protected, internal, protected internal, private), static modifier
+- Parameter modifiers (ref, out, params)
+- STA attribute
+- Partial method
+- Named and optional parameters
+- `Task<dynamic>`
+- Task-Like types
+  
+## Debug
+- F11 works
+- stepping through Main

From 93d25c60a98172915063ca813d581e199bd946c8 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Tue, 18 Apr 2017 11:02:21 -0700
Subject: [PATCH 017/284] Fixing crash with refout on private setter on public
 property (#18771)

---
 .../Emitter/Model/PropertySymbolAdapter.cs    |  94 ++++++-----
 .../Test/Emit/Emit/CompilationEmitTests.cs    | 156 ++++++++++++++----
 .../Emit/NoPia/CommonEmbeddedProperty.cs      |  19 +--
 .../Core/Portable/PEWriter/Members.cs         |   8 +-
 .../Core/Portable/PEWriter/MetadataVisitor.cs |   2 +-
 .../Core/Portable/PEWriter/MetadataWriter.cs  |   2 +-
 .../Portable/Emit/PropertySymbolAdapter.vb    |  26 ++-
 .../Test/Emit/Emit/CompilationEmitTests.vb    | 125 +++++++++++---
 8 files changed, 297 insertions(+), 135 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/PropertySymbolAdapter.cs b/src/Compilers/CSharp/Portable/Emitter/Model/PropertySymbolAdapter.cs
index a9cdc135ae298..d76d3a4868743 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/PropertySymbolAdapter.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/PropertySymbolAdapter.cs
@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using Microsoft.Cci;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.Emit;
@@ -10,41 +11,38 @@
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
     internal partial class PropertySymbol :
-        Cci.IPropertyDefinition
+        IPropertyDefinition
     {
         #region IPropertyDefinition Members
 
-        IEnumerable<Cci.IMethodReference> Cci.IPropertyDefinition.Accessors
+        IEnumerable<IMethodReference> IPropertyDefinition.GetAccessors(EmitContext context)
         {
-            get
-            {
-                CheckDefinitionInvariant();
+            CheckDefinitionInvariant();
 
-                var getMethod = this.GetMethod;
-                if ((object)getMethod != null)
-                {
-                    yield return getMethod;
-                }
+            IMethodReference getMethod = this.GetMethod;
+            if (getMethod != null && getMethod.GetResolvedMethod(context).ShouldInclude(context))
+            {
+                yield return getMethod;
+            }
 
-                var setMethod = this.SetMethod;
-                if ((object)setMethod != null)
-                {
-                    yield return setMethod;
-                }
+            IMethodReference setMethod = this.SetMethod;
+            if (setMethod != null && setMethod.GetResolvedMethod(context).ShouldInclude(context))
+            {
+                yield return setMethod;
+            }
 
-                SourcePropertySymbol sourceProperty = this as SourcePropertySymbol;
-                if ((object)sourceProperty != null)
+            SourcePropertySymbol sourceProperty = this as SourcePropertySymbol;
+            if ((object)sourceProperty != null)
+            {
+                SynthesizedSealedPropertyAccessor synthesizedAccessor = sourceProperty.SynthesizedSealedAccessorOpt;
+                if ((object)synthesizedAccessor != null)
                 {
-                    SynthesizedSealedPropertyAccessor synthesizedAccessor = sourceProperty.SynthesizedSealedAccessorOpt;
-                    if ((object)synthesizedAccessor != null)
-                    {
-                        yield return synthesizedAccessor;
-                    }
+                    yield return synthesizedAccessor;
                 }
             }
         }
 
-        MetadataConstant Cci.IPropertyDefinition.DefaultValue
+        MetadataConstant IPropertyDefinition.DefaultValue
         {
             get
             {
@@ -53,7 +51,7 @@ MetadataConstant Cci.IPropertyDefinition.DefaultValue
             }
         }
 
-        Cci.IMethodReference Cci.IPropertyDefinition.Getter
+        IMethodReference IPropertyDefinition.Getter
         {
             get
             {
@@ -68,7 +66,7 @@ Cci.IMethodReference Cci.IPropertyDefinition.Getter
             }
         }
 
-        bool Cci.IPropertyDefinition.HasDefaultValue
+        bool IPropertyDefinition.HasDefaultValue
         {
             get
             {
@@ -77,7 +75,7 @@ bool Cci.IPropertyDefinition.HasDefaultValue
             }
         }
 
-        bool Cci.IPropertyDefinition.IsRuntimeSpecial
+        bool IPropertyDefinition.IsRuntimeSpecial
         {
             get
             {
@@ -95,7 +93,7 @@ internal virtual bool HasRuntimeSpecialName
             }
         }
 
-        bool Cci.IPropertyDefinition.IsSpecialName
+        bool IPropertyDefinition.IsSpecialName
         {
             get
             {
@@ -104,16 +102,16 @@ bool Cci.IPropertyDefinition.IsSpecialName
             }
         }
 
-        ImmutableArray<Cci.IParameterDefinition> Cci.IPropertyDefinition.Parameters
+        ImmutableArray<IParameterDefinition> IPropertyDefinition.Parameters
         {
             get
             {
                 CheckDefinitionInvariant();
-                return StaticCast<Cci.IParameterDefinition>.From(this.Parameters);
+                return StaticCast<IParameterDefinition>.From(this.Parameters);
             }
         }
 
-        Cci.IMethodReference Cci.IPropertyDefinition.Setter
+        IMethodReference IPropertyDefinition.Setter
         {
             get
             {
@@ -142,7 +140,7 @@ private void CheckDefinitionInvariantAllowEmbedded()
             Debug.Assert(this.ContainingModule is SourceModuleSymbol || this.ContainingAssembly.IsLinked);
         }
 
-        Cci.CallingConvention Cci.ISignature.CallingConvention
+        CallingConvention ISignature.CallingConvention
         {
             get
             {
@@ -151,7 +149,7 @@ Cci.CallingConvention Cci.ISignature.CallingConvention
             }
         }
 
-        ushort Cci.ISignature.ParameterCount
+        ushort ISignature.ParameterCount
         {
             get
             {
@@ -160,31 +158,31 @@ ushort Cci.ISignature.ParameterCount
             }
         }
 
-        ImmutableArray<Cci.IParameterTypeInformation> Cci.ISignature.GetParameters(EmitContext context)
+        ImmutableArray<IParameterTypeInformation> ISignature.GetParameters(EmitContext context)
         {
             CheckDefinitionInvariant();
-            return StaticCast<Cci.IParameterTypeInformation>.From(this.Parameters);
+            return StaticCast<IParameterTypeInformation>.From(this.Parameters);
         }
 
-        ImmutableArray<Cci.ICustomModifier> Cci.ISignature.ReturnValueCustomModifiers
+        ImmutableArray<ICustomModifier> ISignature.ReturnValueCustomModifiers
         {
             get
             {
                 CheckDefinitionInvariantAllowEmbedded();
-                return this.TypeCustomModifiers.As<Cci.ICustomModifier>();
+                return this.TypeCustomModifiers.As<ICustomModifier>();
             }
         }
 
-        ImmutableArray<Cci.ICustomModifier> Cci.ISignature.RefCustomModifiers
+        ImmutableArray<ICustomModifier> ISignature.RefCustomModifiers
         {
             get
             {
                 CheckDefinitionInvariantAllowEmbedded();
-                return this.RefCustomModifiers.As<Cci.ICustomModifier>();
+                return this.RefCustomModifiers.As<ICustomModifier>();
             }
         }
 
-        bool Cci.ISignature.ReturnValueIsByRef
+        bool ISignature.ReturnValueIsByRef
         {
             get
             {
@@ -193,7 +191,7 @@ bool Cci.ISignature.ReturnValueIsByRef
             }
         }
 
-        Cci.ITypeReference Cci.ISignature.GetType(EmitContext context)
+        ITypeReference ISignature.GetType(EmitContext context)
         {
             CheckDefinitionInvariantAllowEmbedded();
             return ((PEModuleBuilder)context.Module).Translate(this.Type,
@@ -205,7 +203,7 @@ Cci.ITypeReference Cci.ISignature.GetType(EmitContext context)
 
         #region ITypeDefinitionMember Members
 
-        Cci.ITypeDefinition Cci.ITypeDefinitionMember.ContainingTypeDefinition
+        ITypeDefinition ITypeDefinitionMember.ContainingTypeDefinition
         {
             get
             {
@@ -214,7 +212,7 @@ Cci.ITypeDefinition Cci.ITypeDefinitionMember.ContainingTypeDefinition
             }
         }
 
-        Cci.TypeMemberVisibility Cci.ITypeDefinitionMember.Visibility
+        TypeMemberVisibility ITypeDefinitionMember.Visibility
         {
             get
             {
@@ -227,7 +225,7 @@ Cci.TypeMemberVisibility Cci.ITypeDefinitionMember.Visibility
 
         #region ITypeMemberReference Members
 
-        Cci.ITypeReference Cci.ITypeMemberReference.GetContainingType(EmitContext context)
+        ITypeReference ITypeMemberReference.GetContainingType(EmitContext context)
         {
             CheckDefinitionInvariant();
             return this.ContainingType;
@@ -237,13 +235,13 @@ Cci.ITypeReference Cci.ITypeMemberReference.GetContainingType(EmitContext contex
 
         #region IReference Members
 
-        void Cci.IReference.Dispatch(Cci.MetadataVisitor visitor)
+        void IReference.Dispatch(MetadataVisitor visitor)
         {
             CheckDefinitionInvariant();
-            visitor.Visit((Cci.IPropertyDefinition)this);
+            visitor.Visit((IPropertyDefinition)this);
         }
 
-        Cci.IDefinition Cci.IReference.AsDefinition(EmitContext context)
+        IDefinition IReference.AsDefinition(EmitContext context)
         {
             CheckDefinitionInvariant();
             return this;
@@ -253,7 +251,7 @@ Cci.IDefinition Cci.IReference.AsDefinition(EmitContext context)
 
         #region INamedEntity Members
 
-        string Cci.INamedEntity.Name
+        string INamedEntity.Name
         {
             get
             {
@@ -264,7 +262,7 @@ string Cci.INamedEntity.Name
 
         #endregion
 
-        private Cci.IMethodReference GetSynthesizedSealedAccessor(MethodKind targetMethodKind)
+        private IMethodReference GetSynthesizedSealedAccessor(MethodKind targetMethodKind)
         {
             SourcePropertySymbol sourceProperty = this as SourcePropertySymbol;
             if ((object)sourceProperty != null)
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
index 05613e9f0c4f3..696bf9bcafa7c 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
@@ -8,7 +8,6 @@
 using System.Reflection.Metadata;
 using System.Reflection.Metadata.Ecma335;
 using System.Reflection.PortableExecutable;
-using System.Text;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
@@ -239,7 +238,7 @@ public static void Main()
         }
 
         [Fact]
-        public void EmitRefAssemblyPrivateMain()
+        public void EmitRefAssembly_PrivateMain()
         {
             CSharpCompilation comp = CreateCompilationWithMscorlib(@"
 public class C
@@ -274,22 +273,114 @@ void VerifyEntryPoint(MemoryStream stream, bool expectZero)
                 int entryPoint = new PEHeaders(stream).CorHeader.EntryPointTokenOrRelativeVirtualAddress;
                 Assert.Equal(expectZero, entryPoint == 0);
             }
+        }
+
+        [Fact]
+        public void EmitRefAssembly_PrivatePropertySetter()
+        {
+            CSharpCompilation comp = CreateCompilationWithMscorlib(@"
+public class C
+{
+    public int PrivateSetter { get; private set; }
+}
+");
 
-            void VerifyMethods(MemoryStream stream, string[] expectedMethods)
+            using (var output = new MemoryStream())
+            using (var metadataOutput = new MemoryStream())
             {
-                stream.Position = 0;
-                var metadataRef = AssemblyMetadata.CreateFromImage(stream.ToArray()).GetReference();
+                EmitResult emitResult = comp.Emit(output, metadataPEStream: metadataOutput,
+                    options: new EmitOptions(includePrivateMembers: false));
+                Assert.True(emitResult.Success);
+                emitResult.Diagnostics.Verify();
 
-                var compWithMetadata = CreateCompilation("", references: new[] { MscorlibRef, metadataRef },
-                    options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
+                VerifyMethods(output, new[] { "System.Int32 C.<PrivateSetter>k__BackingField", "System.Int32 C.PrivateSetter.get", "void C.PrivateSetter.set",
+                    "C..ctor()", "System.Int32 C.PrivateSetter { get; private set; }" });
+                VerifyMethods(metadataOutput, new[] { "System.Int32 C.PrivateSetter.get", "C..ctor()", "System.Int32 C.PrivateSetter { get; }" });
+            }
+        }
 
-                AssertEx.Equal(
-                    expectedMethods,
-                    ((NamedTypeSymbol)compWithMetadata.SourceModule.GetReferencedAssemblySymbols().Last()
-                        .GlobalNamespace.GetMember("C")).GetMembers().Select(m => m.ToTestDisplayString()));
+        [Fact]
+        public void EmitRefAssembly_PrivatePropertyGetter()
+        {
+            CSharpCompilation comp = CreateCompilationWithMscorlib(@"
+public class C
+{
+    public int PrivateGetter { private get; set; }
+}
+");
+
+            using (var output = new MemoryStream())
+            using (var metadataOutput = new MemoryStream())
+            {
+                EmitResult emitResult = comp.Emit(output, metadataPEStream: metadataOutput,
+                    options: new EmitOptions(includePrivateMembers: false));
+                Assert.True(emitResult.Success);
+                emitResult.Diagnostics.Verify();
+
+                VerifyMethods(output, new[] { "System.Int32 C.<PrivateGetter>k__BackingField", "System.Int32 C.PrivateGetter.get", "void C.PrivateGetter.set",
+                    "C..ctor()", "System.Int32 C.PrivateGetter { private get; set; }" });
+                VerifyMethods(metadataOutput, new[] { "void C.PrivateGetter.set", "C..ctor()", "System.Int32 C.PrivateGetter { set; }" });
             }
         }
 
+        [Fact]
+        public void EmitRefAssembly_PrivateIndexerGetter()
+        {
+            CSharpCompilation comp = CreateCompilationWithMscorlib(@"
+public class C
+{
+    public int this[int i] { private get { return 0; } set { } }
+}
+");
+
+            using (var output = new MemoryStream())
+            using (var metadataOutput = new MemoryStream())
+            {
+                EmitResult emitResult = comp.Emit(output, metadataPEStream: metadataOutput,
+                    options: new EmitOptions(includePrivateMembers: false));
+                Assert.True(emitResult.Success);
+                emitResult.Diagnostics.Verify();
+
+                VerifyMethods(output, new[] { "System.Int32 C.this[System.Int32 i].get", "void C.this[System.Int32 i].set",
+                    "C..ctor()", "System.Int32 C.this[System.Int32 i] { private get; set; }" });
+                VerifyMethods(metadataOutput, new[] { "void C.this[System.Int32 i].set", "C..ctor()",
+                    "System.Int32 C.this[System.Int32 i] { set; }" });
+            }
+        }
+
+        [Fact]
+        public void EmitRefAssembly_PrivateAccessorOnEvent()
+        {
+            CSharpCompilation comp = CreateCompilationWithMscorlib(@"
+public class C
+{
+    public event System.Action PrivateAdder { private add { } remove { } }
+    public event System.Action PrivateRemover { add { } private remove { } }
+}
+");
+            comp.VerifyDiagnostics(
+                // (4,47): error CS1609: Modifiers cannot be placed on event accessor declarations
+                //     public event System.Action PrivateAdder { private add { } remove { } }
+                Diagnostic(ErrorCode.ERR_NoModifiersOnAccessor, "private").WithLocation(4, 47),
+                // (5,57): error CS1609: Modifiers cannot be placed on event accessor declarations
+                //     public event System.Action PrivateRemover { add { } private remove { } }
+                Diagnostic(ErrorCode.ERR_NoModifiersOnAccessor, "private").WithLocation(5, 57)
+                );
+        }
+
+        private static void VerifyMethods(MemoryStream stream, string[] expectedMethods)
+        {
+            stream.Position = 0;
+            var metadataRef = AssemblyMetadata.CreateFromImage(stream.ToArray()).GetReference();
+
+            var compWithMetadata = CreateCompilation("", references: new[] { MscorlibRef, metadataRef },
+                options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
+
+            AssertEx.Equal(
+                expectedMethods,
+                compWithMetadata.GetMember<NamedTypeSymbol>("C").GetMembers().Select(m => m.ToTestDisplayString()));
+        }
+
         [Fact]
         public void RefAssembly_HasReferenceAssemblyAttribute()
         {
@@ -679,20 +770,21 @@ public class PublicClass
             var compWithReal = CreateCompilation("", references: new[] { MscorlibRef, realImage },
                 options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
             AssertEx.Equal(
-                compWithReal.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMembers().Select(m => m.ToDisplayString()),
-                new[] { "<Module>", "<>f__AnonymousType0<<anonymous>j__TPar>", "PublicClass" });
+                new[] { "<Module>", "<>f__AnonymousType0<<anonymous>j__TPar>", "PublicClass" },
+                compWithReal.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMembers().Select(m => m.ToDisplayString()));
 
             AssertEx.Equal(
-                ((NamedTypeSymbol)compWithReal.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMember("PublicClass")).GetMembers()
-                    .Select(m => m.ToTestDisplayString()),
                 new[] { "void PublicClass.PublicMethod()", "void PublicClass.PrivateMethod()",
                     "void PublicClass.ProtectedMethod()", "void PublicClass.InternalMethod()",
-                    "PublicClass..ctor()" });
+                    "PublicClass..ctor()" },
+                compWithReal.GetMember<NamedTypeSymbol>("PublicClass").GetMembers()
+                    .Select(m => m.ToTestDisplayString()));
 
-            AssertEx.Equal(compWithReal.SourceModule.GetReferencedAssemblySymbols().Last().GetAttributes().Select(a => a.AttributeClass.ToTestDisplayString()),
+            AssertEx.Equal(
                 new[] { "System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
                     "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
-                    "System.Diagnostics.DebuggableAttribute" });
+                    "System.Diagnostics.DebuggableAttribute" },
+                compWithReal.SourceModule.GetReferencedAssemblySymbols().Last().GetAttributes().Select(a => a.AttributeClass.ToTestDisplayString()));
 
             // verify metadata (types, members, attributes) of the metadata-only assembly
             var emitMetadataOnly = EmitOptions.Default.WithEmitMetadataOnly(true);
@@ -702,20 +794,20 @@ public class PublicClass
             var compWithMetadata = CreateCompilation("", references: new[] { MscorlibRef, metadataImage },
                 options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
             AssertEx.Equal(
-                compWithMetadata.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMembers().Select(m => m.ToDisplayString()),
-                new[] { "<Module>", "PublicClass" });
+                new[] { "<Module>", "PublicClass" },
+                compWithMetadata.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMembers().Select(m => m.ToDisplayString()));
 
             AssertEx.Equal(
-                ((NamedTypeSymbol)compWithMetadata.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMember("PublicClass")).GetMembers()
-                    .Select(m => m.ToTestDisplayString()),
                 new[] { "void PublicClass.PublicMethod()", "void PublicClass.PrivateMethod()",
                     "void PublicClass.ProtectedMethod()", "void PublicClass.InternalMethod()",
-                    "PublicClass..ctor()" });
+                    "PublicClass..ctor()" },
+                compWithMetadata.GetMember<NamedTypeSymbol>("PublicClass").GetMembers().Select(m => m.ToTestDisplayString()));
 
-            AssertEx.Equal(compWithMetadata.SourceModule.GetReferencedAssemblySymbols().Last().GetAttributes().Select(a => a.AttributeClass.ToTestDisplayString()),
+            AssertEx.Equal(
                 new[] { "System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
                     "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
-                    "System.Diagnostics.DebuggableAttribute" });
+                    "System.Diagnostics.DebuggableAttribute" },
+                compWithMetadata.SourceModule.GetReferencedAssemblySymbols().Last().GetAttributes().Select(a => a.AttributeClass.ToTestDisplayString()));
 
             MetadataReaderUtils.AssertEmptyOrThrowNull(comp.EmitToArray(emitMetadataOnly));
 
@@ -727,20 +819,20 @@ public class PublicClass
             var compWithRef = CreateCompilation("", references: new[] { MscorlibRef, refImage },
                 options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
             AssertEx.Equal(
-                compWithRef.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMembers().Select(m => m.ToDisplayString()),
-                new[] { "<Module>", "PublicClass" });
+                new[] { "<Module>", "PublicClass" },
+                compWithRef.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMembers().Select(m => m.ToDisplayString()));
 
             AssertEx.Equal(
-                ((NamedTypeSymbol)compWithRef.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMember("PublicClass")).GetMembers()
-                    .Select(m => m.ToTestDisplayString()),
-                new[] { "void PublicClass.PublicMethod()", "void PublicClass.ProtectedMethod()", "PublicClass..ctor()" });
+                new[] { "void PublicClass.PublicMethod()", "void PublicClass.ProtectedMethod()", "PublicClass..ctor()" },
+                compWithRef.GetMember<NamedTypeSymbol>("PublicClass").GetMembers().Select(m => m.ToTestDisplayString()));
 
-            AssertEx.Equal(compWithRef.SourceModule.GetReferencedAssemblySymbols().Last().GetAttributes().Select(a => a.AttributeClass.ToTestDisplayString()),
+            AssertEx.Equal(
                 new[] {
                     "System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
                     "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
                     "System.Diagnostics.DebuggableAttribute",
-                    "System.Runtime.CompilerServices.ReferenceAssemblyAttribute" });
+                    "System.Runtime.CompilerServices.ReferenceAssemblyAttribute" },
+                compWithRef.SourceModule.GetReferencedAssemblySymbols().Last().GetAttributes().Select(a => a.AttributeClass.ToTestDisplayString()));
 
             MetadataReaderUtils.AssertEmptyOrThrowNull(comp.EmitToArray(emitRefOnly));
         }
diff --git a/src/Compilers/Core/Portable/Emit/NoPia/CommonEmbeddedProperty.cs b/src/Compilers/Core/Portable/Emit/NoPia/CommonEmbeddedProperty.cs
index a942fb11e0125..84bbd6142418c 100644
--- a/src/Compilers/Core/Portable/Emit/NoPia/CommonEmbeddedProperty.cs
+++ b/src/Compilers/Core/Portable/Emit/NoPia/CommonEmbeddedProperty.cs
@@ -81,19 +81,16 @@ Cci.IMethodReference Cci.IPropertyDefinition.Setter
                 get { return _setter; }
             }
 
-            IEnumerable<Cci.IMethodReference> Cci.IPropertyDefinition.Accessors
+            IEnumerable<Cci.IMethodReference> Cci.IPropertyDefinition.GetAccessors(EmitContext context)
             {
-                get
+                if (_getter != null)
+                {
+                    yield return _getter;
+                }
+
+                if (_setter != null)
                 {
-                    if (_getter != null)
-                    {
-                        yield return _getter;
-                    }
-
-                    if (_setter != null)
-                    {
-                        yield return _setter;
-                    }
+                    yield return _setter;
                 }
             }
 
diff --git a/src/Compilers/Core/Portable/PEWriter/Members.cs b/src/Compilers/Core/Portable/PEWriter/Members.cs
index 4c0ffc23e73b7..7d7ae2e42e0f5 100644
--- a/src/Compilers/Core/Portable/PEWriter/Members.cs
+++ b/src/Compilers/Core/Portable/PEWriter/Members.cs
@@ -10,7 +10,6 @@
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.Debugging;
 using Microsoft.CodeAnalysis.Emit;
-using Roslyn.Utilities;
 using EmitContext = Microsoft.CodeAnalysis.Emit.EmitContext;
 
 namespace Microsoft.Cci
@@ -714,7 +713,7 @@ internal interface IPropertyDefinition : ISignature, ITypeDefinitionMember
         /// <summary>
         /// A list of methods that are associated with the property.
         /// </summary>
-        IEnumerable<IMethodReference> Accessors { get; }
+        IEnumerable<IMethodReference> GetAccessors(EmitContext context);
 
         /// <summary>
         /// A compile time constant value that provides the default value for the property. (Who uses this and why?)
@@ -985,6 +984,11 @@ internal static bool HasBody(this IMethodDefinition methodDef)
         /// </summary>
         public static bool ShouldInclude(this ITypeDefinitionMember member, EmitContext context)
         {
+            if (context.IncludePrivateMembers)
+            {
+                return true;
+            }
+
             var method = member as IMethodDefinition;
             if (method != null && method.IsVirtual)
             {
diff --git a/src/Compilers/Core/Portable/PEWriter/MetadataVisitor.cs b/src/Compilers/Core/Portable/PEWriter/MetadataVisitor.cs
index 35e844b80a736..165b05231543d 100644
--- a/src/Compilers/Core/Portable/PEWriter/MetadataVisitor.cs
+++ b/src/Compilers/Core/Portable/PEWriter/MetadataVisitor.cs
@@ -464,7 +464,7 @@ public void Visit(IEnumerable<IPropertyDefinition> properties)
 
         public virtual void Visit(IPropertyDefinition propertyDefinition)
         {
-            this.Visit(propertyDefinition.Accessors);
+            this.Visit(propertyDefinition.GetAccessors(Context));
             this.Visit(propertyDefinition.Parameters);
         }
 
diff --git a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
index 8c910f748deaf..3b558b9396401 100644
--- a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
@@ -2579,7 +2579,7 @@ private void PopulateMethodSemanticsTableRows()
             foreach (IPropertyDefinition propertyDef in this.GetPropertyDefs())
             {
                 var association = GetPropertyDefIndex(propertyDef);
-                foreach (IMethodReference accessorMethod in propertyDef.Accessors)
+                foreach (IMethodReference accessorMethod in propertyDef.GetAccessors(Context))
                 {
                     MethodSemanticsAttributes semantics;
                     if (accessorMethod == propertyDef.Setter)
diff --git a/src/Compilers/VisualBasic/Portable/Emit/PropertySymbolAdapter.vb b/src/Compilers/VisualBasic/Portable/Emit/PropertySymbolAdapter.vb
index 432f7f5ea9dee..b98377bbda743 100644
--- a/src/Compilers/VisualBasic/Portable/Emit/PropertySymbolAdapter.vb
+++ b/src/Compilers/VisualBasic/Portable/Emit/PropertySymbolAdapter.vb
@@ -11,21 +11,19 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
     Friend Partial Class PropertySymbol
         Implements IPropertyDefinition
 
-        Private ReadOnly Property IPropertyDefinitionAccessors As IEnumerable(Of IMethodReference) Implements IPropertyDefinition.Accessors
-            Get
-                CheckDefinitionInvariant()
+        Private Iterator Function IPropertyDefinitionAccessors(context As EmitContext) As IEnumerable(Of IMethodReference) Implements IPropertyDefinition.GetAccessors
+            CheckDefinitionInvariant()
 
-                If Me.GetMethod IsNot Nothing And Me.SetMethod IsNot Nothing Then
-                    Return {Me.GetMethod, Me.SetMethod}
-                ElseIf Me.GetMethod IsNot Nothing Then
-                    Return SpecializedCollections.SingletonEnumerable(Me.GetMethod)
-                ElseIf Me.SetMethod IsNot Nothing Then
-                    Return SpecializedCollections.SingletonEnumerable(Me.SetMethod)
-                Else
-                    Return SpecializedCollections.EmptyEnumerable(Of IMethodReference)()
-                End If
-            End Get
-        End Property
+            Dim getter As IMethodReference = Me.GetMethod
+            If getter IsNot Nothing AndAlso getter.GetResolvedMethod(context).ShouldInclude(context) Then
+                Yield getter
+            End If
+
+            Dim setter As IMethodReference = Me.SetMethod
+            If setter IsNot Nothing AndAlso setter.GetResolvedMethod(context).ShouldInclude(context) Then
+                Yield setter
+            End If
+        End Function
 
         Private ReadOnly Property IPropertyDefinitionDefaultValue As MetadataConstant Implements IPropertyDefinition.DefaultValue
             Get
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
index 68f38a335d6cb..f79bc3827226a 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
@@ -297,6 +297,73 @@ End Class
             End Using
         End Sub
 
+        <Fact>
+        Private Sub EmitRefAssembly_PrivatePropertyGetter()
+            Dim source As String = "
+Public Class C
+    Property P As Integer
+        Private Get
+            Return 0
+        End Get
+        Set
+        End Set
+    End Property
+End Class"
+
+            Dim comp = CreateCompilationWithMscorlib(source, options:=TestOptions.DebugDll.WithDeterministic(True))
+
+            Using output As New MemoryStream()
+                Using metadataOutput As New MemoryStream()
+                    Dim emitResult = comp.Emit(output, metadataPEStream:=metadataOutput,
+                                               options:=EmitOptions.Default.WithIncludePrivateMembers(False))
+                    Assert.True(emitResult.Success)
+                    emitResult.Diagnostics.Verify()
+
+                    VerifyMethod(output, {"Sub C..ctor()", "Function C.get_P() As System.Int32", "Sub C.set_P(Value As System.Int32)", "Property C.P As System.Int32"})
+                    VerifyMethod(metadataOutput, {"Sub C..ctor()", "Sub C.set_P(Value As System.Int32)", "WriteOnly Property C.P As System.Int32"})
+                End Using
+            End Using
+        End Sub
+
+        <Fact>
+        Private Sub EmitRefAssembly_PrivatePropertySetter()
+            Dim source As String = "
+Public Class C
+    Property P As Integer
+        Get
+            Return 0
+        End Get
+        Private Set
+        End Set
+    End Property
+End Class"
+
+            Dim comp = CreateCompilationWithMscorlib(source, options:=TestOptions.DebugDll.WithDeterministic(True))
+
+            Using output As New MemoryStream()
+                Using metadataOutput As New MemoryStream()
+                    Dim emitResult = comp.Emit(output, metadataPEStream:=metadataOutput,
+                                               options:=EmitOptions.Default.WithIncludePrivateMembers(False))
+                    Assert.True(emitResult.Success)
+                    emitResult.Diagnostics.Verify()
+
+                    VerifyMethod(output, {"Sub C..ctor()", "Function C.get_P() As System.Int32", "Sub C.set_P(Value As System.Int32)", "Property C.P As System.Int32"})
+                    VerifyMethod(metadataOutput, {"Sub C..ctor()", "Function C.get_P() As System.Int32", "ReadOnly Property C.P As System.Int32"})
+                End Using
+            End Using
+        End Sub
+
+        Private Shared Sub VerifyMethod(stream As MemoryStream, expectedMethods As String())
+            stream.Position = 0
+            Dim metadataRef = AssemblyMetadata.CreateFromImage(stream.ToArray()).GetReference()
+
+            Dim compWithMetadata = CreateCompilation("", references:={MscorlibRef, metadataRef},
+                                                     options:=TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All))
+
+            AssertEx.Equal(expectedMethods,
+                           compWithMetadata.GetMember(Of NamedTypeSymbol)("C").GetMembers().Select(Function(m) m.ToTestDisplayString()))
+        End Sub
+
         <Fact>
         Public Sub RefAssembly_HasReferenceAssemblyAttribute()
             Dim emitRefAssembly = EmitOptions.Default.WithEmitMetadataOnly(True).WithIncludePrivateMembers(False)
@@ -734,20 +801,22 @@ End Class"
             Dim compWithReal = CreateCompilation("", references:={MscorlibRef, realImage},
                             options:=TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All))
             Dim realAssembly = compWithReal.SourceModule.GetReferencedAssemblySymbols().Last()
-            AssertEx.SetEqual(realAssembly.GlobalNamespace.GetMembers().Select(Function(m) m.ToDisplayString()),
-                {"<Module>", "PublicClass"})
+            AssertEx.SetEqual(
+                {"<Module>", "PublicClass"},
+                realAssembly.GlobalNamespace.GetMembers().Select(Function(m) m.ToDisplayString()))
 
             AssertEx.SetEqual(
-                DirectCast(realAssembly.GlobalNamespace.GetMember("PublicClass"), NamedTypeSymbol).GetMembers().
-                                Select(Function(m) m.ToTestDisplayString()),
-                            {"Sub PublicClass.PublicMethod()", "Sub PublicClass.PrivateMethod()",
-                                "Sub PublicClass.InternalMethod()", "Sub PublicClass.ProtectedMethod()",
-                                "Sub PublicClass.AbstractMethod()", "Sub PublicClass..ctor()"})
+                {"Sub PublicClass.PublicMethod()", "Sub PublicClass.PrivateMethod()",
+                    "Sub PublicClass.InternalMethod()", "Sub PublicClass.ProtectedMethod()",
+                    "Sub PublicClass.AbstractMethod()", "Sub PublicClass..ctor()"},
+                compWithReal.GetMember(Of NamedTypeSymbol)("PublicClass").GetMembers().
+                    Select(Function(m) m.ToTestDisplayString()))
 
-            AssertEx.SetEqual(realAssembly.GetAttributes().Select(Function(a) a.AttributeClass.ToTestDisplayString()),
+            AssertEx.SetEqual(
                 {"System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
                     "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
-                    "System.Diagnostics.DebuggableAttribute"})
+                    "System.Diagnostics.DebuggableAttribute"},
+                realAssembly.GetAttributes().Select(Function(a) a.AttributeClass.ToTestDisplayString()))
 
             ' verify metadata (types, members, attributes) of the metadata-only assembly
             Dim emitMetadataOnly = EmitOptions.Default.WithEmitMetadataOnly(True)
@@ -757,20 +826,22 @@ End Class"
             Dim compWithMetadata = CreateCompilation("", references:={MscorlibRef, metadataImage},
                             options:=TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All))
             Dim metadataAssembly As AssemblySymbol = compWithMetadata.SourceModule.GetReferencedAssemblySymbols().Last()
-            AssertEx.SetEqual(metadataAssembly.GlobalNamespace.GetMembers().Select(Function(m) m.ToDisplayString()),
-                {"<Module>", "PublicClass"})
+            AssertEx.SetEqual(
+                {"<Module>", "PublicClass"},
+                metadataAssembly.GlobalNamespace.GetMembers().Select(Function(m) m.ToDisplayString()))
 
             AssertEx.SetEqual(
-                DirectCast(metadataAssembly.GlobalNamespace.GetMember("PublicClass"), NamedTypeSymbol).GetMembers().
-                                Select(Function(m) m.ToTestDisplayString()),
-                            {"Sub PublicClass.PublicMethod()", "Sub PublicClass.PrivateMethod()",
-                                "Sub PublicClass.InternalMethod()", "Sub PublicClass.ProtectedMethod()",
-                                "Sub PublicClass.AbstractMethod()", "Sub PublicClass..ctor()"})
+                {"Sub PublicClass.PublicMethod()", "Sub PublicClass.PrivateMethod()",
+                    "Sub PublicClass.InternalMethod()", "Sub PublicClass.ProtectedMethod()",
+                    "Sub PublicClass.AbstractMethod()", "Sub PublicClass..ctor()"},
+                compWithMetadata.GetMember(Of NamedTypeSymbol)("PublicClass").GetMembers().
+                    Select(Function(m) m.ToTestDisplayString()))
 
-            AssertEx.SetEqual(metadataAssembly.GetAttributes().Select(Function(a) a.AttributeClass.ToTestDisplayString()),
+            AssertEx.SetEqual(
                 {"System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
                     "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
-                    "System.Diagnostics.DebuggableAttribute"})
+                    "System.Diagnostics.DebuggableAttribute"},
+                metadataAssembly.GetAttributes().Select(Function(a) a.AttributeClass.ToTestDisplayString()))
 
             MetadataReaderUtils.AssertEmptyOrThrowNull(comp.EmitToArray(emitMetadataOnly))
 
@@ -782,20 +853,22 @@ End Class"
             Dim compWithRef = CreateCompilation("", references:={MscorlibRef, refImage},
                             options:=TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All))
             Dim refAssembly As AssemblySymbol = compWithRef.SourceModule.GetReferencedAssemblySymbols().Last()
-            AssertEx.SetEqual(refAssembly.GlobalNamespace.GetMembers().Select(Function(m) m.ToDisplayString()),
-                {"<Module>", "PublicClass"})
+            AssertEx.SetEqual(
+                {"<Module>", "PublicClass"},
+                refAssembly.GlobalNamespace.GetMembers().Select(Function(m) m.ToDisplayString()))
 
             AssertEx.SetEqual(
-                DirectCast(refAssembly.GlobalNamespace.GetMember("PublicClass"), NamedTypeSymbol).GetMembers().
-                                Select(Function(m) m.ToTestDisplayString()),
-                            {"Sub PublicClass..ctor()", "Sub PublicClass.PublicMethod()",
-                                "Sub PublicClass.ProtectedMethod()", "Sub PublicClass.AbstractMethod()"})
+                {"Sub PublicClass..ctor()", "Sub PublicClass.PublicMethod()",
+                    "Sub PublicClass.ProtectedMethod()", "Sub PublicClass.AbstractMethod()"},
+                compWithRef.GetMember(Of NamedTypeSymbol)("PublicClass").GetMembers().
+                    Select(Function(m) m.ToTestDisplayString()))
 
-            AssertEx.SetEqual(refAssembly.GetAttributes().Select(Function(a) a.AttributeClass.ToTestDisplayString()),
+            AssertEx.SetEqual(
                 {"System.Runtime.CompilerServices.CompilationRelaxationsAttribute",
                     "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute",
                     "System.Diagnostics.DebuggableAttribute",
-                    "System.Runtime.CompilerServices.ReferenceAssemblyAttribute"})
+                    "System.Runtime.CompilerServices.ReferenceAssemblyAttribute"},
+                refAssembly.GetAttributes().Select(Function(a) a.AttributeClass.ToTestDisplayString()))
 
             MetadataReaderUtils.AssertEmptyOrThrowNull(comp.EmitToArray(emitRefOnly))
         End Sub

From 8058a70b432911829e88f7aea2736ae4f1c4fd60 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Wed, 19 Apr 2017 16:39:59 -0700
Subject: [PATCH 018/284] Address additional feedback on PR #18771 (#18828)

---
 .../Emitter/Model/PropertySymbolAdapter.cs    | 10 +++----
 .../Test/Emit/Emit/CompilationEmitTests.cs    | 28 +++++++++++++++++++
 .../Portable/Emit/PropertySymbolAdapter.vb    |  8 +++---
 3 files changed, 37 insertions(+), 9 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/PropertySymbolAdapter.cs b/src/Compilers/CSharp/Portable/Emitter/Model/PropertySymbolAdapter.cs
index d76d3a4868743..217a3dccd7f62 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/PropertySymbolAdapter.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/PropertySymbolAdapter.cs
@@ -19,20 +19,20 @@ IEnumerable<IMethodReference> IPropertyDefinition.GetAccessors(EmitContext conte
         {
             CheckDefinitionInvariant();
 
-            IMethodReference getMethod = this.GetMethod;
-            if (getMethod != null && getMethod.GetResolvedMethod(context).ShouldInclude(context))
+            MethodSymbol getMethod = this.GetMethod;
+            if (getMethod != null && getMethod.ShouldInclude(context))
             {
                 yield return getMethod;
             }
 
-            IMethodReference setMethod = this.SetMethod;
-            if (setMethod != null && setMethod.GetResolvedMethod(context).ShouldInclude(context))
+            MethodSymbol setMethod = this.SetMethod;
+            if (setMethod != null && setMethod.ShouldInclude(context))
             {
                 yield return setMethod;
             }
 
             SourcePropertySymbol sourceProperty = this as SourcePropertySymbol;
-            if ((object)sourceProperty != null)
+            if ((object)sourceProperty != null && sourceProperty.ShouldInclude(context))
             {
                 SynthesizedSealedPropertyAccessor synthesizedAccessor = sourceProperty.SynthesizedSealedAccessorOpt;
                 if ((object)synthesizedAccessor != null)
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
index 5c14eeabdaa8f..abc39c4f664aa 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
@@ -348,6 +348,34 @@ public class C
             }
         }
 
+        [Fact]
+        public void EmitRefAssembly_SealedPropertyWithInternalInheritedGetter()
+        {
+            CSharpCompilation comp = CreateStandardCompilation(@"
+public class Base
+{
+    public virtual int Property { internal get { return 0; } set { } }
+}
+public class C : Base
+{
+    public sealed override int Property { set { } }
+}
+");
+
+            using (var output = new MemoryStream())
+            using (var metadataOutput = new MemoryStream())
+            {
+                EmitResult emitResult = comp.Emit(output, metadataPEStream: metadataOutput,
+                    options: new EmitOptions(includePrivateMembers: false));
+                emitResult.Diagnostics.Verify();
+                Assert.True(emitResult.Success);
+
+                VerifyMethods(output, new[] { "void C.Property.set", "C..ctor()", "System.Int32 C.Property.get", "System.Int32 C.Property { internal get; set; }" });
+                // A getter is synthesized on C.Property so that it can be marked as sealed. It is emitted despite being internal because it is virtual.
+                VerifyMethods(metadataOutput, new[] {  "void C.Property.set", "C..ctor()", "System.Int32 C.Property.get", "System.Int32 C.Property { internal get; set; }" });
+            }
+        }
+
         [Fact]
         public void EmitRefAssembly_PrivateAccessorOnEvent()
         {
diff --git a/src/Compilers/VisualBasic/Portable/Emit/PropertySymbolAdapter.vb b/src/Compilers/VisualBasic/Portable/Emit/PropertySymbolAdapter.vb
index b98377bbda743..761e6fd41cbff 100644
--- a/src/Compilers/VisualBasic/Portable/Emit/PropertySymbolAdapter.vb
+++ b/src/Compilers/VisualBasic/Portable/Emit/PropertySymbolAdapter.vb
@@ -14,13 +14,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
         Private Iterator Function IPropertyDefinitionAccessors(context As EmitContext) As IEnumerable(Of IMethodReference) Implements IPropertyDefinition.GetAccessors
             CheckDefinitionInvariant()
 
-            Dim getter As IMethodReference = Me.GetMethod
-            If getter IsNot Nothing AndAlso getter.GetResolvedMethod(context).ShouldInclude(context) Then
+            Dim getter As MethodSymbol = Me.GetMethod
+            If getter IsNot Nothing AndAlso getter.ShouldInclude(context) Then
                 Yield getter
             End If
 
-            Dim setter As IMethodReference = Me.SetMethod
-            If setter IsNot Nothing AndAlso setter.GetResolvedMethod(context).ShouldInclude(context) Then
+            Dim setter As MethodSymbol = Me.SetMethod
+            If setter IsNot Nothing AndAlso setter.ShouldInclude(context) Then
                 Yield setter
             End If
         End Function

From 3c12e98413d27d1a759a34ff62226a40a87fe78e Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 24 Apr 2017 17:19:03 -0700
Subject: [PATCH 019/284] Move DocumentHighlights (i.e. HighlightReferences)
 out of process.

---
 .../CSharp/CSharpEditorFeatures.csproj        |  2 -
 .../CSharpDocumentHighlightsService.cs        | 13 ---
 src/EditorFeatures/Core/EditorFeatures.csproj | 19 ++--
 ...viewReferenceHighlightingTaggerProvider.cs |  2 +-
 ...HighlightingAdditionalReferenceProvider.cs | 14 ---
 ...htReferenceCommandHandler.StartComparer.cs |  2 +-
 ...ivateToHighlightReferenceCommandHandler.cs |  2 +-
 ...ReferenceHighlightingViewTaggerProvider.cs |  3 +-
 .../Tags}/DefinitionHighlightTag.cs           |  2 +-
 .../Tags}/DefinitionHighlightTagDefinition.cs |  2 +-
 .../Tags}/ReferenceHighlightTag.cs            |  2 +-
 .../Tags}/WrittenReferenceHighlightTag.cs     |  2 +-
 .../WrittenReferenceHighlightTagDefinition.cs |  2 +-
 .../AbstractReferenceHighlightingTests.vb     | 11 ++-
 .../VisualBasic/BasicEditorFeatures.vbproj    |  2 -
 ...HighlightingAdditionalReferenceProvider.vb | 18 ----
 .../CSharp/Portable/CSharpFeatures.csproj     |  1 +
 .../CSharpDocumentHighlightsService.cs}       | 26 ++---
 .../AbstractDocumentHighlightsService.cs      | 61 ++++++++----
 ...bstractDocumentHighlightsService_Remote.cs | 30 ++++++
 .../DocumentHighlightingOptions.cs            | 15 +++
 .../IDocumentHighlightsService.cs             |  3 +-
 .../IRemoteDocumentHighlights.cs              | 94 +++++++++++++++++++
 src/Features/Core/Portable/Features.csproj    |  5 +
 .../VisualBasic/Portable/BasicFeatures.vbproj |  1 +
 .../VisualBasicDocumentHighlightsService.vb   |  6 +-
 ...bstractTableDataSourceFindUsagesContext.cs |  2 +-
 .../WithReferencesFindUsagesContext.cs        |  2 +-
 .../WithoutReferencesFindUsagesContext.cs     |  2 +-
 .../Entries/DocumentSpanEntry.cs              |  4 +-
 .../CSharp/CSharpReferenceHighlighting.cs     |  3 +-
 .../VisualBasic/BasicReferenceHighlighting.cs |  3 +-
 .../TestUtilities/WellKnownTagNames.cs        |  2 +-
 .../Remote/ServiceHub/ServiceHub.csproj       |  1 +
 .../CodeAnalysisService_DocumentHighlights.cs | 28 ++++++
 35 files changed, 270 insertions(+), 117 deletions(-)
 delete mode 100644 src/EditorFeatures/CSharp/HighlightReferences/CSharpDocumentHighlightsService.cs
 delete mode 100644 src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IReferenceHighlightingAdditionalReferenceProvider.cs
 rename src/EditorFeatures/Core/{Implementation => }/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs (87%)
 rename src/EditorFeatures/Core/{Implementation => }/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs (98%)
 rename src/EditorFeatures/Core/{Implementation => }/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs (98%)
 rename src/EditorFeatures/Core/{Implementation/ReferenceHighlighting => ReferenceHighlighting/Tags}/DefinitionHighlightTag.cs (88%)
 rename src/EditorFeatures/Core/{Implementation/ReferenceHighlighting => ReferenceHighlighting/Tags}/DefinitionHighlightTagDefinition.cs (92%)
 rename src/EditorFeatures/Core/{Implementation/ReferenceHighlighting => ReferenceHighlighting/Tags}/ReferenceHighlightTag.cs (87%)
 rename src/EditorFeatures/Core/{Implementation/ReferenceHighlighting => ReferenceHighlighting/Tags}/WrittenReferenceHighlightTag.cs (88%)
 rename src/EditorFeatures/Core/{Implementation/ReferenceHighlighting => ReferenceHighlighting/Tags}/WrittenReferenceHighlightTagDefinition.cs (91%)
 delete mode 100644 src/EditorFeatures/VisualBasic/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.vb
 rename src/{EditorFeatures/CSharp/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.cs => Features/CSharp/Portable/DocumentHighlighting/CSharpDocumentHighlightsService.cs} (70%)
 rename src/{EditorFeatures/Core/Implementation/ReferenceHighlighting => Features/Core/Portable/DocumentHighlighting}/AbstractDocumentHighlightsService.cs (82%)
 create mode 100644 src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService_Remote.cs
 create mode 100644 src/Features/Core/Portable/DocumentHighlighting/DocumentHighlightingOptions.cs
 rename src/{EditorFeatures/Core/Implementation/ReferenceHighlighting => Features/Core/Portable/DocumentHighlighting}/IDocumentHighlightsService.cs (95%)
 create mode 100644 src/Features/Core/Portable/DocumentHighlighting/IRemoteDocumentHighlights.cs
 rename src/{EditorFeatures/VisualBasic/HighlightReferences => Features/VisualBasic/Portable/DocumentHighlighting}/VisualBasicDocumentHighlightsService.vb (73%)
 create mode 100644 src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_DocumentHighlights.cs

diff --git a/src/EditorFeatures/CSharp/CSharpEditorFeatures.csproj b/src/EditorFeatures/CSharp/CSharpEditorFeatures.csproj
index 516c7b22ee5eb..2fd0b81875d7f 100644
--- a/src/EditorFeatures/CSharp/CSharpEditorFeatures.csproj
+++ b/src/EditorFeatures/CSharp/CSharpEditorFeatures.csproj
@@ -136,14 +136,12 @@
     <Compile Include="Highlighting\KeywordHighlighters\UnsafeStatementHighlighter.cs" />
     <Compile Include="Highlighting\KeywordHighlighters\UsingStatementHighlighter.cs" />
     <Compile Include="Highlighting\KeywordHighlighters\YieldStatementHighlighter.cs" />
-    <Compile Include="HighlightReferences\CSharpDocumentHighlightsService.cs" />
     <Compile Include="InlineRename\CSharpEditorInlineRenameService.cs" />
     <Compile Include="LanguageServices\CSharpContentTypeLanguageService.cs" />
     <Compile Include="LineSeparators\CSharpLineSeparatorService.cs" />
     <Compile Include="NavigationBar\CSharpNavigationBarItemService.cs" />
     <Compile Include="QuickInfo\SemanticQuickInfoProvider.cs" />
     <Compile Include="QuickInfo\SyntacticQuickInfoProvider.cs" />
-    <Compile Include="ReferenceHighlighting\ReferenceHighlightingAdditionalReferenceProvider.cs" />
     <Compile Include="RenameTracking\CSharpRenameTrackingCodeFixProvider.cs" />
     <Compile Include="RenameTracking\CSharpRenameTrackingLanguageHeuristicsService.cs" />
     <Compile Include="SplitStringLiteral\SplitStringLiteralCommandHandler.cs" />
diff --git a/src/EditorFeatures/CSharp/HighlightReferences/CSharpDocumentHighlightsService.cs b/src/EditorFeatures/CSharp/HighlightReferences/CSharpDocumentHighlightsService.cs
deleted file mode 100644
index c1f3baf669ed0..0000000000000
--- a/src/EditorFeatures/CSharp/HighlightReferences/CSharpDocumentHighlightsService.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Composition;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
-using Microsoft.CodeAnalysis.Host.Mef;
-
-namespace Microsoft.CodeAnalysis.Editor.CSharp.HighlightReferences
-{
-    [ExportLanguageService(typeof(IDocumentHighlightsService), LanguageNames.CSharp), Shared]
-    internal class CSharpDocumentHighlightsService : AbstractDocumentHighlightsService
-    {
-    }
-}
diff --git a/src/EditorFeatures/Core/EditorFeatures.csproj b/src/EditorFeatures/Core/EditorFeatures.csproj
index 8d01f690249fd..101e4d12ec8ed 100644
--- a/src/EditorFeatures/Core/EditorFeatures.csproj
+++ b/src/EditorFeatures/Core/EditorFeatures.csproj
@@ -118,6 +118,14 @@
     <Compile Include="Implementation\Structure\BlockTagState.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionSetComparer.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionsSource.cs" />
+    <Compile Include="ReferenceHighlighting\NagivateToHighlightReferenceCommandHandler.cs" />
+    <Compile Include="ReferenceHighlighting\NagivateToHighlightReferenceCommandHandler.StartComparer.cs" />
+    <Compile Include="ReferenceHighlighting\ReferenceHighlightingViewTaggerProvider.cs" />
+    <Compile Include="ReferenceHighlighting\Tags\DefinitionHighlightTag.cs" />
+    <Compile Include="ReferenceHighlighting\Tags\DefinitionHighlightTagDefinition.cs" />
+    <Compile Include="ReferenceHighlighting\Tags\ReferenceHighlightTag.cs" />
+    <Compile Include="ReferenceHighlighting\Tags\WrittenReferenceHighlightTag.cs" />
+    <Compile Include="ReferenceHighlighting\Tags\WrittenReferenceHighlightTagDefinition.cs" />
     <Compile Include="SymbolSearch\IAddReferenceDatabaseWrapper.cs" />
     <Compile Include="SymbolSearch\IDatabaseFactoryService.cs" />
     <Compile Include="SymbolSearch\IDelayService.cs" />
@@ -582,8 +590,6 @@
     <Compile Include="Implementation\Peek\PeekableItemSource.cs" />
     <Compile Include="Implementation\Peek\PeekableItemSourceProvider.cs" />
     <Compile Include="Implementation\Peek\PeekHelpers.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\WrittenReferenceHighlightTag.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\WrittenReferenceHighlightTagDefinition.cs" />
     <Compile Include="Implementation\RenameTracking\IRenameTrackingLanguageHeuristicsService.cs" />
     <Compile Include="Implementation\RenameTracking\RenameTrackingCancellationCommandHandler.cs" />
     <Compile Include="Implementation\RenameTracking\RenameTrackingTagDefinition.cs" />
@@ -595,15 +601,6 @@
     <Compile Include="Implementation\Preview\PreviewConflictViewTaggerProvider.cs" />
     <Compile Include="Implementation\Preview\PreviewFactoryService.cs" />
     <Compile Include="Implementation\Preview\PreviewWarningViewTaggerProvider.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\AbstractDocumentHighlightsService.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\DefinitionHighlightTag.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\DefinitionHighlightTagDefinition.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\IDocumentHighlightsService.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\IReferenceHighlightingAdditionalReferenceProvider.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\NagivateToHighlightReferenceCommandHandler.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\NagivateToHighlightReferenceCommandHandler.StartComparer.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\ReferenceHighlightingViewTaggerProvider.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\ReferenceHighlightTag.cs" />
     <Compile Include="Implementation\RenameTracking\AbstractRenameTrackingCodeFixProvider.cs" />
     <Compile Include="Implementation\RenameTracking\RenameTrackingDiagnosticAnalyzer.cs" />
     <Compile Include="Implementation\RenameTracking\RenameTrackingTaggerProvider.cs" />
diff --git a/src/EditorFeatures/Core/Implementation/Preview/PreviewReferenceHighlightingTaggerProvider.cs b/src/EditorFeatures/Core/Implementation/Preview/PreviewReferenceHighlightingTaggerProvider.cs
index 29a2060e254e3..5c90ff6b8f179 100644
--- a/src/EditorFeatures/Core/Implementation/Preview/PreviewReferenceHighlightingTaggerProvider.cs
+++ b/src/EditorFeatures/Core/Implementation/Preview/PreviewReferenceHighlightingTaggerProvider.cs
@@ -6,7 +6,7 @@
 using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Text.Tagging;
 using Microsoft.VisualStudio.Utilities;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.Preview
 {
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IReferenceHighlightingAdditionalReferenceProvider.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IReferenceHighlightingAdditionalReferenceProvider.cs
deleted file mode 100644
index 694a5b6e505a2..0000000000000
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IReferenceHighlightingAdditionalReferenceProvider.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Host;
-
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
-{
-    internal interface IReferenceHighlightingAdditionalReferenceProvider : ILanguageService
-    {
-        Task<IEnumerable<Location>> GetAdditionalReferencesAsync(Document document, ISymbol symbol, CancellationToken cancellationToken);
-    }
-}
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs b/src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
similarity index 87%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
index 76b72d5268f3b..125416fd75162 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
@@ -3,7 +3,7 @@
 using System.Collections.Generic;
 using Microsoft.VisualStudio.Text;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     internal partial class NavigateToHighlightReferenceCommandHandler
     {
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs b/src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
similarity index 98%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
index a0997e4009c8a..07a6b67793a85 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
@@ -14,7 +14,7 @@
 using Microsoft.VisualStudio.Text.Tagging;
 using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     [ExportCommandHandler(PredefinedCommandHandlerNames.NavigateToHighlightedReference,
        ContentTypeNames.RoslynContentType)]
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs b/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
similarity index 98%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
index cbad756b7bd6a..e2367ad5f5d3d 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
@@ -6,6 +6,7 @@
 using System.ComponentModel.Composition;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 using Microsoft.CodeAnalysis.Editor.Tagging;
@@ -21,7 +22,7 @@
 using Microsoft.VisualStudio.Utilities;
 using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     [Export(typeof(IViewTaggerProvider))]
     [ContentType(ContentTypeNames.RoslynContentType)]
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTag.cs b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTag.cs
similarity index 88%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTag.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTag.cs
index 2f5873a759429..0b974c620bfa2 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTag.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTag.cs
@@ -2,7 +2,7 @@
 
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     internal class DefinitionHighlightTag : NavigableHighlightTag
     {
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTagDefinition.cs b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTagDefinition.cs
similarity index 92%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTagDefinition.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTagDefinition.cs
index b5a8023f8297e..5580291757cf8 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTagDefinition.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTagDefinition.cs
@@ -5,7 +5,7 @@
 using Microsoft.VisualStudio.Text.Classification;
 using Microsoft.VisualStudio.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     [Export(typeof(EditorFormatDefinition))]
     [Name(DefinitionHighlightTag.TagId)]
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightTag.cs b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/ReferenceHighlightTag.cs
similarity index 87%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightTag.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/Tags/ReferenceHighlightTag.cs
index 6c7d2cddc337b..299c701a98780 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightTag.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/ReferenceHighlightTag.cs
@@ -2,7 +2,7 @@
 
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     internal class ReferenceHighlightTag : NavigableHighlightTag
     {
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTag.cs b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTag.cs
similarity index 88%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTag.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTag.cs
index b4d35d64ae6b1..d6f8df3342be5 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTag.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTag.cs
@@ -2,7 +2,7 @@
 
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     internal class WrittenReferenceHighlightTag : NavigableHighlightTag
     {
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTagDefinition.cs b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTagDefinition.cs
similarity index 91%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTagDefinition.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTagDefinition.cs
index 8db19cc5cb2b4..74323824a5056 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTagDefinition.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTagDefinition.cs
@@ -5,7 +5,7 @@
 using Microsoft.VisualStudio.Text.Classification;
 using Microsoft.VisualStudio.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     [Export(typeof(EditorFormatDefinition))]
     [Name(WrittenReferenceHighlightTag.TagId)]
diff --git a/src/EditorFeatures/Test2/ReferenceHighlighting/AbstractReferenceHighlightingTests.vb b/src/EditorFeatures/Test2/ReferenceHighlighting/AbstractReferenceHighlightingTests.vb
index ab5ab6a8ab80b..7c9591274611f 100644
--- a/src/EditorFeatures/Test2/ReferenceHighlighting/AbstractReferenceHighlightingTests.vb
+++ b/src/EditorFeatures/Test2/ReferenceHighlighting/AbstractReferenceHighlightingTests.vb
@@ -1,7 +1,8 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports System.Threading
-Imports Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+Imports Microsoft.CodeAnalysis.DocumentHighlighting
+Imports Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 Imports Microsoft.CodeAnalysis.Editor.Shared.Extensions
 Imports Microsoft.CodeAnalysis.Editor.Shared.Options
 Imports Microsoft.CodeAnalysis.Editor.Shared.Tagging
@@ -16,9 +17,17 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.ReferenceHighlighting
 
     Public MustInherit Class AbstractReferenceHighlightingTests
         Protected Async Function VerifyHighlightsAsync(test As XElement, Optional optionIsEnabled As Boolean = True) As Tasks.Task
+            Await VerifyHighlightsAsync(test, optionIsEnabled, outOfProcess:=False)
+            Await VerifyHighlightsAsync(test, optionIsEnabled, outOfProcess:=True)
+        End Function
+
+        Private Async Function VerifyHighlightsAsync(test As XElement, optionIsEnabled As Boolean, outOfProcess As Boolean) As Tasks.Task
             Using workspace = TestWorkspace.Create(test)
                 WpfTestCase.RequireWpfFact($"{NameOf(AbstractReferenceHighlightingTests)}.VerifyHighlightsAsync creates asynchronous taggers")
 
+                workspace.Options = workspace.Options.WithChangedOption(
+                    DocumentHighlightingOptions.OutOfProcessAllowed, outOfProcess)
+
                 Dim tagProducer = New ReferenceHighlightingViewTaggerProvider(
                     workspace.GetService(Of IForegroundNotificationService),
                     workspace.GetService(Of ISemanticChangeNotificationService),
diff --git a/src/EditorFeatures/VisualBasic/BasicEditorFeatures.vbproj b/src/EditorFeatures/VisualBasic/BasicEditorFeatures.vbproj
index e80f4930b6093..6154c915e22c6 100644
--- a/src/EditorFeatures/VisualBasic/BasicEditorFeatures.vbproj
+++ b/src/EditorFeatures/VisualBasic/BasicEditorFeatures.vbproj
@@ -129,7 +129,6 @@
     <Compile Include="Highlighting\KeywordHighlighters\XmlEmbeddedExpressionHighlighter.vb" />
     <Compile Include="Highlighting\KeywordHighlighters\XmlProcessingInstructionHighlighter.vb" />
     <Compile Include="Highlighting\KeywordHighlightingHelpers.vb" />
-    <Compile Include="HighlightReferences\VisualBasicDocumentHighlightsService.vb" />
     <Compile Include="ImplementAbstractClass\ImplementAbstractClassCommandHandler.vb" />
     <Compile Include="ImplementInterface\ImplementInterfaceCommandHandler.vb" />
     <Compile Include="InlineRename\VisualBasicEditorInlineRenameService.vb" />
@@ -155,7 +154,6 @@
     <Compile Include="NavigationBar\GenerateMethodItem.vb" />
     <Compile Include="NavigationBar\VisualBasicNavigationBarItemService.vb" />
     <Compile Include="QuickInfo\SemanticQuickInfoProvider.vb" />
-    <Compile Include="ReferenceHighlighting\ReferenceHighlightingAdditionalReferenceProvider.vb" />
     <Compile Include="RenameTracking\BasicRenameTrackingLanguageHeuristicsService.vb" />
     <Compile Include="RenameTracking\RenameTrackingCodeFixProvider.vb" />
     <Compile Include="TextStructureNavigation\TextStructureNavigatorProvider.vb" />
diff --git a/src/EditorFeatures/VisualBasic/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.vb b/src/EditorFeatures/VisualBasic/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.vb
deleted file mode 100644
index 2c95b09d3a2fb..0000000000000
--- a/src/EditorFeatures/VisualBasic/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.vb
+++ /dev/null
@@ -1,18 +0,0 @@
-' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-Imports System.Composition
-Imports System.Threading
-Imports System.Threading.Tasks
-Imports Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
-Imports Microsoft.CodeAnalysis.Host.Mef
-
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.ReferenceHighlighting
-    <ExportLanguageService(GetType(IReferenceHighlightingAdditionalReferenceProvider), LanguageNames.VisualBasic), [Shared]>
-    Friend Class ReferenceHighlightingAdditionalReferenceProvider
-        Implements IReferenceHighlightingAdditionalReferenceProvider
-
-        Public Function GetAdditionalReferencesAsync(document As Document, symbol As ISymbol, cancellationToken As CancellationToken) As Task(Of IEnumerable(Of Location)) Implements IReferenceHighlightingAdditionalReferenceProvider.GetAdditionalReferencesAsync
-            Return SpecializedTasks.EmptyEnumerable(Of Location)()
-        End Function
-    End Class
-End Namespace
diff --git a/src/Features/CSharp/Portable/CSharpFeatures.csproj b/src/Features/CSharp/Portable/CSharpFeatures.csproj
index 653a38493d46f..6e565f66676d7 100644
--- a/src/Features/CSharp/Portable/CSharpFeatures.csproj
+++ b/src/Features/CSharp/Portable/CSharpFeatures.csproj
@@ -81,6 +81,7 @@
     </Compile>
     <Compile Include="DesignerAttributes\CSharpDesignerAttributeService.cs" />
     <Compile Include="Completion\CompletionProviders\DeclarationNameCompletionProvider.cs" />
+    <Compile Include="DocumentHighlighting\CSharpDocumentHighlightsService.cs" />
     <Compile Include="ImplementAbstractClass\CSharpImplementAbstractClassCodeFixProvider.cs" />
     <Compile Include="ImplementInterface\CSharpImplementInterfaceCodeFixProvider.cs" />
     <Compile Include="InitializeParameter\CSharpAddParameterCheckCodeRefactoringProvider.cs" />
diff --git a/src/EditorFeatures/CSharp/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.cs b/src/Features/CSharp/Portable/DocumentHighlighting/CSharpDocumentHighlightsService.cs
similarity index 70%
rename from src/EditorFeatures/CSharp/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.cs
rename to src/Features/CSharp/Portable/DocumentHighlighting/CSharpDocumentHighlightsService.cs
index 2321c81cc552e..4788978fd5719 100644
--- a/src/EditorFeatures/CSharp/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.cs
+++ b/src/Features/CSharp/Portable/DocumentHighlighting/CSharpDocumentHighlightsService.cs
@@ -1,32 +1,31 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Composition;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.Host.Mef;
-using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.CSharp.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.CSharp.DocumentHighlighting
 {
-    [ExportLanguageService(typeof(IReferenceHighlightingAdditionalReferenceProvider), LanguageNames.CSharp), Shared]
-    internal class ReferenceHighlightingAdditionalReferenceProvider : IReferenceHighlightingAdditionalReferenceProvider
+    [ExportLanguageService(typeof(IDocumentHighlightsService), LanguageNames.CSharp), Shared]
+    internal class CSharpDocumentHighlightsService : AbstractDocumentHighlightsService
     {
-        public async Task<IEnumerable<Location>> GetAdditionalReferencesAsync(
+        protected override async Task<ImmutableArray<Location>> GetAdditionalReferencesAsync(
             Document document, ISymbol symbol, CancellationToken cancellationToken)
         {
             // The FindRefs engine won't find references through 'var' for performance reasons.
             // Also, they are not needed for things like rename/sig change, and the normal find refs
-            // feature.  However, we would lke the results to be highlighted to get a good experience
+            // feature.  However, we would like the results to be highlighted to get a good experience
             // while editing (especially since highlighting may have been invoked off of 'var' in
             // the first place).
             //
             // So we look for the references through 'var' directly in this file and add them to the
             // results found by the engine.
-            List<Location> results = null;
+            var results = ArrayBuilder<Location>.GetInstance();
 
             if (symbol is INamedTypeSymbol && symbol.Name != "var")
             {
@@ -52,18 +51,13 @@ public async Task<IEnumerable<Location>> GetAdditionalReferencesAsync(
 
                         if (originalSymbol.Equals(boundSymbol))
                         {
-                            if (results == null)
-                            {
-                                results = new List<Location>();
-                            }
-
                             results.Add(type.GetLocation());
                         }
                     }
                 }
             }
 
-            return results ?? SpecializedCollections.EmptyEnumerable<Location>();
+            return results.ToImmutableAndFree();
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/AbstractDocumentHighlightsService.cs b/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService.cs
similarity index 82%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/AbstractDocumentHighlightsService.cs
rename to src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService.cs
index 8a90b0062620f..91b1933bd7692 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/AbstractDocumentHighlightsService.cs
+++ b/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService.cs
@@ -14,12 +14,47 @@
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.DocumentHighlighting
 {
-    internal abstract class AbstractDocumentHighlightsService : IDocumentHighlightsService
+    internal abstract partial class AbstractDocumentHighlightsService : IDocumentHighlightsService
     {
         public async Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsAsync(
             Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken)
+        {
+            var (succeeded, highlights) = await GetDocumentHighlightsInRemoteProcessAsync(
+                document, position, documentsToSearch, cancellationToken).ConfigureAwait(false);
+
+            if (succeeded)
+            {
+                return highlights;
+            }
+
+            return await GetDocumentHighlightsInCurrentProcessAsync(
+                document, position, documentsToSearch, cancellationToken).ConfigureAwait(false);
+        }
+
+        private async Task<(bool succeeded, ImmutableArray<DocumentHighlights> highlights)> GetDocumentHighlightsInRemoteProcessAsync(
+            Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken)
+        {
+            using (var session = await TryGetRemoteSessionAsync(
+                document.Project.Solution, cancellationToken).ConfigureAwait(false))
+            {
+                if (session == null)
+                {
+                    return (succeeded: false, ImmutableArray<DocumentHighlights>.Empty);
+                }
+
+                var result = await session.InvokeAsync<SerializableDocumentHighlights[]>(
+                    nameof(IRemoteDocumentHighlights.GetDocumentHighlightsAsync),
+                    document.Id,
+                    position,
+                    documentsToSearch.Select(d => d.Id).ToArray()).ConfigureAwait(false);
+                return (true, SerializableDocumentHighlights.Rehydrate(result, document.Project.Solution));
+            }
+        }
+
+        private async Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsInCurrentProcessAsync(
+            Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken)
         {
             // use speculative semantic model to see whether we are on a symbol we can do HR
             var span = new TextSpan(position, 0);
@@ -41,11 +76,11 @@ public async Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsAsync
 
             // Get unique tags for referenced symbols
             return await GetTagsForReferencedSymbolAsync(
-                new SymbolAndProjectId(symbol, document.Project.Id), documentsToSearch, 
+                new SymbolAndProjectId(symbol, document.Project.Id), documentsToSearch,
                 solution, cancellationToken).ConfigureAwait(false);
         }
 
-        private async Task<ISymbol> GetSymbolToSearchAsync(Document document, int position, SemanticModel semanticModel, ISymbol symbol, CancellationToken cancellationToken)
+        private static async Task<ISymbol> GetSymbolToSearchAsync(Document document, int position, SemanticModel semanticModel, ISymbol symbol, CancellationToken cancellationToken)
         {
             // see whether we can use the symbol as it is
             var currentSemanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
@@ -82,7 +117,7 @@ await SymbolFinder.FindReferencesAsync(
             return ImmutableArray<DocumentHighlights>.Empty;
         }
 
-        private bool ShouldConsiderSymbol(ISymbol symbol)
+        private static bool ShouldConsiderSymbol(ISymbol symbol)
         {
             switch (symbol.Kind)
             {
@@ -132,19 +167,13 @@ private async Task<ImmutableArray<DocumentHighlights>> FilterAndCreateSpansAsync
                 documentsToSearch, cancellationToken).ConfigureAwait(false);
         }
 
-        private Task<IEnumerable<Location>> GetAdditionalReferencesAsync(
+        protected virtual Task<ImmutableArray<Location>> GetAdditionalReferencesAsync(
             Document document, ISymbol symbol, CancellationToken cancellationToken)
         {
-            var additionalReferenceProvider = document.Project.LanguageServices.GetService<IReferenceHighlightingAdditionalReferenceProvider>();
-            if (additionalReferenceProvider != null)
-            {
-                return additionalReferenceProvider.GetAdditionalReferencesAsync(document, symbol, cancellationToken);
-            }
-
-            return Task.FromResult(SpecializedCollections.EmptyEnumerable<Location>());
+            return SpecializedTasks.EmptyImmutableArray<Location>();
         }
 
-        private async Task<ImmutableArray<DocumentHighlights>> CreateSpansAsync(
+        private static async Task<ImmutableArray<DocumentHighlights>> CreateSpansAsync(
             Solution solution,
             ISymbol symbol,
             IEnumerable<ReferencedSymbol> references,
@@ -252,7 +281,7 @@ private static bool ShouldIncludeDefinition(ISymbol symbol)
             return true;
         }
 
-        private async Task AddLocationSpan(Location location, Solution solution, HashSet<DocumentSpan> spanSet, MultiDictionary<Document, HighlightSpan> tagList, HighlightSpanKind kind, CancellationToken cancellationToken)
+        private static async Task AddLocationSpan(Location location, Solution solution, HashSet<DocumentSpan> spanSet, MultiDictionary<Document, HighlightSpan> tagList, HighlightSpanKind kind, CancellationToken cancellationToken)
         {
             var span = await GetLocationSpanAsync(solution, location, cancellationToken).ConfigureAwait(false);
             if (span != null && !spanSet.Contains(span.Value))
@@ -262,7 +291,7 @@ private async Task AddLocationSpan(Location location, Solution solution, HashSet
             }
         }
 
-        private async Task<DocumentSpan?> GetLocationSpanAsync(
+        private static async Task<DocumentSpan?> GetLocationSpanAsync(
             Solution solution, Location location, CancellationToken cancellationToken)
         {
             try
diff --git a/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService_Remote.cs b/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService_Remote.cs
new file mode 100644
index 0000000000000..7efad4a9663df
--- /dev/null
+++ b/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService_Remote.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Remote;
+
+namespace Microsoft.CodeAnalysis.DocumentHighlighting
+{
+    internal abstract partial class AbstractDocumentHighlightsService : IDocumentHighlightsService
+    {
+        private static async Task<RemoteHostClient.Session> TryGetRemoteSessionAsync(
+            Solution solution, CancellationToken cancellationToken)
+        {
+            var outOfProcessAllowed = solution.Workspace.Options.GetOption(DocumentHighlightingOptions.OutOfProcessAllowed);
+            if (!outOfProcessAllowed)
+            {
+                return null;
+            }
+
+            var client = await solution.Workspace.TryGetRemoteHostClientAsync(cancellationToken).ConfigureAwait(false);
+            if (client == null)
+            {
+                return null;
+            }
+
+            return await client.TryCreateCodeAnalysisServiceSessionAsync(
+                solution, cancellationToken).ConfigureAwait(false);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Features/Core/Portable/DocumentHighlighting/DocumentHighlightingOptions.cs b/src/Features/Core/Portable/DocumentHighlighting/DocumentHighlightingOptions.cs
new file mode 100644
index 0000000000000..0363999301f11
--- /dev/null
+++ b/src/Features/Core/Portable/DocumentHighlighting/DocumentHighlightingOptions.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis.Options;
+
+namespace Microsoft.CodeAnalysis.DocumentHighlighting
+{
+    internal static class DocumentHighlightingOptions
+    {
+        private const string LocalRegistryPath = @"Roslyn\Features\DocumentHighlighting\";
+
+        public static readonly Option<bool> OutOfProcessAllowed = new Option<bool>(
+            nameof(DocumentHighlightingOptions), nameof(OutOfProcessAllowed), defaultValue: false,
+            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(OutOfProcessAllowed)));
+    }
+}
\ No newline at end of file
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs b/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
similarity index 95%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs
rename to src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
index f86be931963c1..0e08d4418c4f5 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs
+++ b/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
@@ -1,13 +1,12 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.Editor
+namespace Microsoft.CodeAnalysis.DocumentHighlighting
 {
     internal enum HighlightSpanKind
     {
diff --git a/src/Features/Core/Portable/DocumentHighlighting/IRemoteDocumentHighlights.cs b/src/Features/Core/Portable/DocumentHighlighting/IRemoteDocumentHighlights.cs
new file mode 100644
index 0000000000000..b58c6f35a18fd
--- /dev/null
+++ b/src/Features/Core/Portable/DocumentHighlighting/IRemoteDocumentHighlights.cs
@@ -0,0 +1,94 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.DocumentHighlighting
+{
+    internal interface IRemoteDocumentHighlights
+    {
+        Task<SerializableDocumentHighlights[]> GetDocumentHighlightsAsync(
+            DocumentId documentId, int position, DocumentId[] documentIdsToSearch);
+    }
+
+    internal struct SerializableDocumentHighlights
+    {
+        public DocumentId DocumentId;
+        public SerializableHighlightSpan[] HighlightSpans;
+
+        public static ImmutableArray<DocumentHighlights> Rehydrate(SerializableDocumentHighlights[] array, Solution solution)
+        {
+            var result = ArrayBuilder<DocumentHighlights>.GetInstance(array.Length);
+            foreach (var dehydrated in array)
+            {
+                result.Push(dehydrated.Rehydrate(solution));
+            }
+
+            return result.ToImmutableAndFree();
+        }
+
+        private DocumentHighlights Rehydrate(Solution solution)
+            => new DocumentHighlights(solution.GetDocument(DocumentId), SerializableHighlightSpan.Rehydrate(HighlightSpans));
+
+        public static SerializableDocumentHighlights[] Dehydrate(ImmutableArray<DocumentHighlights> array)
+        {
+            var result = new SerializableDocumentHighlights[array.Length];
+            var index = 0;
+            foreach (var highlights in array)
+            {
+                result[index] = Dehydrate(highlights);
+                index++;
+            }
+
+            return result;
+        }
+
+        private static SerializableDocumentHighlights Dehydrate(DocumentHighlights highlights)
+            => new SerializableDocumentHighlights
+            {
+                DocumentId = highlights.Document.Id,
+                HighlightSpans = SerializableHighlightSpan.Dehydrate(highlights.HighlightSpans)
+            };
+    }
+
+    internal struct SerializableHighlightSpan
+    {
+        public TextSpan TextSpan;
+        public HighlightSpanKind Kind;
+
+        internal static SerializableHighlightSpan[] Dehydrate(ImmutableArray<HighlightSpan> array)
+        {
+            var result = new SerializableHighlightSpan[array.Length];
+            var index = 0;
+            foreach (var span in array)
+            {
+                result[index] = Dehydrate(span);
+                index++;
+            }
+
+            return result;
+        }
+
+        private static SerializableHighlightSpan Dehydrate(HighlightSpan span)
+            => new SerializableHighlightSpan
+            {
+                Kind = span.Kind,
+                TextSpan = span.TextSpan
+            };
+
+        internal static ImmutableArray<HighlightSpan> Rehydrate(SerializableHighlightSpan[] array)
+        {
+            var result = ArrayBuilder<HighlightSpan>.GetInstance(array.Length);
+            foreach (var dehydrated in array)
+            {
+                result.Push(dehydrated.Rehydrate());
+            }
+
+            return result.ToImmutableAndFree();
+        }
+
+        private HighlightSpan Rehydrate()
+            => new HighlightSpan(TextSpan, Kind);
+    }
+}
\ No newline at end of file
diff --git a/src/Features/Core/Portable/Features.csproj b/src/Features/Core/Portable/Features.csproj
index 4d756be89c071..f34cebb3a0a61 100644
--- a/src/Features/Core/Portable/Features.csproj
+++ b/src/Features/Core/Portable/Features.csproj
@@ -128,6 +128,7 @@
     <Compile Include="Diagnostics\DiagnosticArguments.cs" />
     <Compile Include="Diagnostics\DiagnosticResultSerializer.cs" />
     <Compile Include="Diagnostics\SymbolAnalysisContextExtensions.cs" />
+    <Compile Include="DocumentHighlighting\DocumentHighlightingOptions.cs" />
     <Compile Include="EncapsulateField\EncapsulateFieldRefactoringProvider.cs" />
     <Compile Include="ExtractInterface\ExtractInterfaceCodeRefactoringProvider.cs" />
     <Compile Include="CodeFixes\FixAllOccurrences\FixSomeCodeAction.cs" />
@@ -153,6 +154,10 @@
     <Compile Include="GenerateFromMembers\SelectedMemberInfo.cs" />
     <Compile Include="ImplementType\ImplementTypeOptions.cs" />
     <Compile Include="ImplementType\ImplementTypeOptionsProvider.cs" />
+    <Compile Include="DocumentHighlighting\AbstractDocumentHighlightsService.cs" />
+    <Compile Include="DocumentHighlighting\AbstractDocumentHighlightsService_Remote.cs" />
+    <Compile Include="DocumentHighlighting\IDocumentHighlightsService.cs" />
+    <Compile Include="DocumentHighlighting\IRemoteDocumentHighlights.cs" />
     <Compile Include="RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsCodeFixProvider.cs" />
     <Compile Include="RemoveUnnecessaryImports\IUnnecessaryImportsService.cs" />
     <Compile Include="NavigateTo\AbstractNavigateToSearchService.SearchResult.cs" />
diff --git a/src/Features/VisualBasic/Portable/BasicFeatures.vbproj b/src/Features/VisualBasic/Portable/BasicFeatures.vbproj
index 4f643a168c0ea..1e6d8416210af 100644
--- a/src/Features/VisualBasic/Portable/BasicFeatures.vbproj
+++ b/src/Features/VisualBasic/Portable/BasicFeatures.vbproj
@@ -66,6 +66,7 @@
       <Link>InternalUtilities\LambdaUtilities.vb</Link>
     </Compile>
     <Compile Include="AddPackage\VisualBasicAddSpecificPackageCodeFixProvider.vb" />
+    <Compile Include="DocumentHighlighting\VisualBasicDocumentHighlightsService.vb" />
     <Compile Include="InitializeParameter\InitializeParameterHelpers.vb" />
     <Compile Include="InitializeParameter\VisualBasicAddParameterCheckCodeRefactoringProvider.vb" />
     <Compile Include="ChangeSignature\ChangeSignatureFormattingRule.vb" />
diff --git a/src/EditorFeatures/VisualBasic/HighlightReferences/VisualBasicDocumentHighlightsService.vb b/src/Features/VisualBasic/Portable/DocumentHighlighting/VisualBasicDocumentHighlightsService.vb
similarity index 73%
rename from src/EditorFeatures/VisualBasic/HighlightReferences/VisualBasicDocumentHighlightsService.vb
rename to src/Features/VisualBasic/Portable/DocumentHighlighting/VisualBasicDocumentHighlightsService.vb
index b0693439b5de7..2f925d3749ed3 100644
--- a/src/EditorFeatures/VisualBasic/HighlightReferences/VisualBasicDocumentHighlightsService.vb
+++ b/src/Features/VisualBasic/Portable/DocumentHighlighting/VisualBasicDocumentHighlightsService.vb
@@ -1,13 +1,13 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports System.Composition
-Imports Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+Imports Microsoft.CodeAnalysis.DocumentHighlighting
 Imports Microsoft.CodeAnalysis.Host.Mef
 
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.HighlightReferences
+Namespace Microsoft.CodeAnalysis.VisualBasic.DocumentHighlighting
     <ExportLanguageService(GetType(IDocumentHighlightsService), LanguageNames.VisualBasic), [Shared]>
     Friend Class VisualBasicDocumentHighlightsService
         Inherits AbstractDocumentHighlightsService
 
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/VisualStudio/Core/Next/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs b/src/VisualStudio/Core/Next/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
index efc411f7e6c11..299f790bcbb34 100644
--- a/src/VisualStudio/Core/Next/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
+++ b/src/VisualStudio/Core/Next/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
@@ -4,11 +4,11 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.CodeAnalysis.Formatting;
diff --git a/src/VisualStudio/Core/Next/FindReferences/Contexts/WithReferencesFindUsagesContext.cs b/src/VisualStudio/Core/Next/FindReferences/Contexts/WithReferencesFindUsagesContext.cs
index 9973893c2464d..765612f4c86b2 100644
--- a/src/VisualStudio/Core/Next/FindReferences/Contexts/WithReferencesFindUsagesContext.cs
+++ b/src/VisualStudio/Core/Next/FindReferences/Contexts/WithReferencesFindUsagesContext.cs
@@ -8,7 +8,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Completion;
-using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.VisualStudio.Shell.FindAllReferences;
 using Roslyn.Utilities;
diff --git a/src/VisualStudio/Core/Next/FindReferences/Contexts/WithoutReferencesFindUsagesContext.cs b/src/VisualStudio/Core/Next/FindReferences/Contexts/WithoutReferencesFindUsagesContext.cs
index 5a5f6a2b02bf8..2456a495cfef6 100644
--- a/src/VisualStudio/Core/Next/FindReferences/Contexts/WithoutReferencesFindUsagesContext.cs
+++ b/src/VisualStudio/Core/Next/FindReferences/Contexts/WithoutReferencesFindUsagesContext.cs
@@ -3,7 +3,7 @@
 using System;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.VisualStudio.Shell.FindAllReferences;
 using Roslyn.Utilities;
diff --git a/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs b/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs
index 1293153a2734e..c1069f8a25855 100644
--- a/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs
+++ b/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs
@@ -7,16 +7,16 @@
 using System.Windows.Media;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Preview;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Extensions;
 using Microsoft.VisualStudio.PlatformUI;
-using Microsoft.VisualStudio.Shell.TableControl;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
 
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpReferenceHighlighting.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpReferenceHighlighting.cs
index e216ac66345ab..047419eff0750 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpReferenceHighlighting.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpReferenceHighlighting.cs
@@ -3,11 +3,10 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
-using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
 using Roslyn.Test.Utilities;
 using Xunit;
 
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicReferenceHighlighting.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicReferenceHighlighting.cs
index 4520ab6b597c7..04ba08bdc2e46 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicReferenceHighlighting.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicReferenceHighlighting.cs
@@ -3,11 +3,10 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
-using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
 using Roslyn.Test.Utilities;
 using Xunit;
 
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/WellKnownTagNames.cs b/src/VisualStudio/IntegrationTest/TestUtilities/WellKnownTagNames.cs
index d765685a409f3..98dd6cba799a0 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/WellKnownTagNames.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/WellKnownTagNames.cs
@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
 
 namespace Microsoft.VisualStudio.IntegrationTest.Utilities
 {
diff --git a/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj b/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj
index 26d66f271df3b..d6f317e7361a8 100644
--- a/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj
+++ b/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj
@@ -62,6 +62,7 @@
     </Compile>
     <Compile Include="Services\CodeAnalysisService_CodeLens.cs" />
     <Compile Include="Services\CodeAnalysisService_DesignerAttributes.cs" />
+    <Compile Include="Services\CodeAnalysisService_DocumentHighlights.cs" />
     <Compile Include="Services\CodeAnalysisService_TodoComments.cs" />
     <Compile Include="Services\CodeAnalysisService_SymbolFinder.cs" />
     <Compile Include="Services\RemoteSymbolSearchUpdateEngine.cs" />
diff --git a/src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_DocumentHighlights.cs b/src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_DocumentHighlights.cs
new file mode 100644
index 0000000000000..b98c8e58a9146
--- /dev/null
+++ b/src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_DocumentHighlights.cs
@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+
+namespace Microsoft.CodeAnalysis.Remote
+{
+    // root level service for all Roslyn services
+    internal partial class CodeAnalysisService : IRemoteDocumentHighlights
+    {
+        public async Task<SerializableDocumentHighlights[]> GetDocumentHighlightsAsync(
+            DocumentId documentId, int position, DocumentId[] documentIdsToSearch)
+        {
+            var solution = await GetSolutionAsync().ConfigureAwait(false);
+            var document = solution.GetDocument(documentId);
+            var documentsToSearch = ImmutableHashSet.CreateRange(documentIdsToSearch.Select(solution.GetDocument));
+
+            var service = document.GetLanguageService<IDocumentHighlightsService>();
+            var result = await service.GetDocumentHighlightsAsync(
+                document, position, documentsToSearch, CancellationToken).ConfigureAwait(false);
+
+            return SerializableDocumentHighlights.Dehydrate(result);
+        }
+    }
+}
\ No newline at end of file

From f904ea01466986e7746571f3f878d97551b6e416 Mon Sep 17 00:00:00 2001
From: Tom Meschter <tom.meschter@microsoft.com>
Date: Wed, 29 Mar 2017 10:23:14 -0700
Subject: [PATCH 020/284] Ensure non-fatal exceptions are actually thrown

When a process crashes due to an unhandled exception or an explicit `Environment.FailFast()` or similar, the collected call stack and (possible) memory dump will be very close to the point of failure. This is obviously desirable when you need to diagnose an issue from crash reports.

When we catch an exception and report it as a non-fatal event, however, that collection may happen well after the failure. There are a couple of things we need to do to ensure we get the proper data.

First, we need to ensure that the exceptions we report have actually been thrown. The call stack within an exception is populated _when it is thrown_, not when it is created. As the analysis tools on the back end use the exception stack trace to bucketize failures, we currently have a large number of reports where we know something went wrong, but we don't know where.

Second, our reporting mechanisms are best called from within an exception filter. This is because the filter runs at the point where the exception was thrown, before control flow has passed to a catch block. If we collect a memory dump at this point it will preserve the stack frames that led to the exception which is very useful for debugging.

The resulting pattern is often a little odd: we throw an exception, report it through the exception filter, immediately catch it, and then do nothing in the catch block. However, this ensures we collect actionable data.
---
 .../Preview/DifferenceViewerPreview.cs        |  8 ++++-
 .../SymbolSearchUpdateEngine.Update.cs        | 33 ++++++++++++-------
 ...crementalAnalyzer_GetDiagnosticsForSpan.cs |  8 ++++-
 ...tServiceFactory.RemoteHostClientService.cs |  8 ++++-
 ...sEditorAdaptersFactoryServiceExtensions.cs | 11 +++++--
 .../FindSymbols/DeclaredSymbolInfo.cs         | 10 +++++-
 .../SyntaxTree/SyntaxTreeIndex_Create.cs      |  9 ++++-
 7 files changed, 68 insertions(+), 19 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/Preview/DifferenceViewerPreview.cs b/src/EditorFeatures/Core/Implementation/Preview/DifferenceViewerPreview.cs
index 488e64fd63437..21a4d20ef56a9 100644
--- a/src/EditorFeatures/Core/Implementation/Preview/DifferenceViewerPreview.cs
+++ b/src/EditorFeatures/Core/Implementation/Preview/DifferenceViewerPreview.cs
@@ -41,7 +41,13 @@ public void Dispose()
                 return;
             }
 
-            FatalError.ReportWithoutCrash(new Exception($"Dispose is not called how? viewer state : {_viewer.IsClosed}"));
+            try
+            {
+                throw new Exception($"Dispose is not called how? viewer state : {_viewer.IsClosed}");
+            }
+            catch (Exception e) when (FatalError.ReportWithoutCrash(e))
+            {
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/EditorFeatures/Core/SymbolSearch/SymbolSearchUpdateEngine.Update.cs b/src/EditorFeatures/Core/SymbolSearch/SymbolSearchUpdateEngine.Update.cs
index 50414749dba46..1033192212910 100644
--- a/src/EditorFeatures/Core/SymbolSearch/SymbolSearchUpdateEngine.Update.cs
+++ b/src/EditorFeatures/Core/SymbolSearch/SymbolSearchUpdateEngine.Update.cs
@@ -564,15 +564,14 @@ private async Task RepeatIOAsync(Func<Task> action)
                         await action().ConfigureAwait(false);
                         return;
                     }
-                    catch (Exception e)
+                    catch (Exception e) when (IOUtilities.IsNormalIOException(e) || _service._reportAndSwallowException(e))
                     {
-                        // Normal IO exception. Don't bother reporting it.  We don't want to get
-                        // lots of hits just because we couldn't write a file because of something
-                        // like an anti-virus tool lockign the file.
-                        if (!IOUtilities.IsNormalIOException(e))
-                        {
-                            _service._reportAndSwallowException(e);
-                        }
+                        // The exception filter above might be a little funny looking. We always
+                        // want to enter this catch block, but if we ran into a normal IO exception
+                        // we shouldn't bother reporting it. We don't want to get lots of hits just
+                        // because something like an anti-virus tool locked the file and we
+                        // couldn't write to it. The call to IsNormalIOException will shortcut
+                        // around the reporting in this case.
 
                         var delay = _service._delayService.FileWriteDelay;
                         await _service.LogExceptionAsync(e, $"Operation failed. Trying again after {delay}").ConfigureAwait(false);
@@ -587,8 +586,13 @@ private async Task<ValueTuple<bool, byte[]>> TryParseDatabaseElementAsync(XEleme
                 var contentsAttribute = element.Attribute(ContentAttributeName);
                 if (contentsAttribute == null)
                 {
-                    _service._reportAndSwallowException(
-                        new FormatException($"Database element invalid. Missing '{ContentAttributeName}' attribute"));
+                    try
+                    {
+                        throw new FormatException($"Database element invalid. Missing '{ContentAttributeName}' attribute");
+                    }
+                    catch (FormatException e) when (_service._reportAndSwallowException(e))
+                    {
+                    }
 
                     return ValueTuple.Create(false, (byte[])null);
                 }
@@ -607,8 +611,13 @@ private async Task<ValueTuple<bool, byte[]>> TryParseDatabaseElementAsync(XEleme
 
                     if (!StringComparer.Ordinal.Equals(expectedChecksum, actualChecksum))
                     {
-                        _service._reportAndSwallowException(
-                            new FormatException($"Checksum mismatch: expected != actual. {expectedChecksum} != {actualChecksum}"));
+                        try
+                        {
+                            throw new FormatException($"Checksum mismatch: expected != actual. {expectedChecksum} != {actualChecksum}");
+                        }
+                        catch (FormatException e) when (_service._reportAndSwallowException(e))
+                        {
+                        }
 
                         return ValueTuple.Create(false, (byte[])null);
                     }
diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs
index f183ebfde0bc6..2377e4d1dde03 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs
@@ -232,7 +232,13 @@ private void VerifyDiagnostics(SemanticModel model)
                 if (!AreEquivalent(rangeDiagnostics, wholeDiagnostics))
                 {
                     // otherwise, report non-fatal watson so that we can fix those cases
-                    FatalError.ReportWithoutCrash(new Exception("Bug in GetDiagnostics"));
+                    try
+                    {
+                        throw new Exception("Bug in GetDiagnostics");
+                    }
+                    catch (Exception e) when (FatalError.ReportWithoutCrash(e))
+                    {
+                    }
 
                     // make sure we hold onto these for debugging.
                     GC.KeepAlive(rangeDeclaractionDiagnostics);
diff --git a/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs b/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs
index be22435e65026..1adee03e9c3ba 100644
--- a/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs
@@ -248,7 +248,13 @@ private void OnConnectionChanged(object sender, bool connected)
 
                     // s_lastRemoteClientTask info should be saved in the dump
                     // report NFW when connection is closed unless it is proper shutdown
-                    FatalError.ReportWithoutCrash(new Exception("Connection to remote host closed"));
+                    try
+                    {
+                        throw new Exception("Connection to remote host closed");
+                    }
+                    catch (Exception e) when (FatalError.ReportWithoutCrash(e))
+                    {
+                    }
 
                     // use info bar to show warning to users
                     var infoBarUIs = new List<ErrorReportingUI>();
diff --git a/src/VisualStudio/Core/Def/Utilities/IVsEditorAdaptersFactoryServiceExtensions.cs b/src/VisualStudio/Core/Def/Utilities/IVsEditorAdaptersFactoryServiceExtensions.cs
index 191931c59a046..4160826763987 100644
--- a/src/VisualStudio/Core/Def/Utilities/IVsEditorAdaptersFactoryServiceExtensions.cs
+++ b/src/VisualStudio/Core/Def/Utilities/IVsEditorAdaptersFactoryServiceExtensions.cs
@@ -30,8 +30,15 @@ public static IOleUndoManager TryGetUndoManager(
                 var message = contextDocumentId == null
                     ? $"{nameof(contextDocumentId)} was null."
                     : $"{nameof(contextDocumentId)} was not null.";
-                FatalError.ReportWithoutCrash(new InvalidOperationException(
-                    "Could not retrieve document. " + message));
+
+                try
+                {
+                    throw new InvalidOperationException("Could not retrieve document. " + message);
+                }
+                catch(InvalidOperationException e) when (FatalError.ReportWithoutCrash(e))
+                {
+                }
+
                 return null;
             }
 
diff --git a/src/Workspaces/Core/Portable/FindSymbols/DeclaredSymbolInfo.cs b/src/Workspaces/Core/Portable/FindSymbols/DeclaredSymbolInfo.cs
index 0afb72e6fc75f..253e34c9bbaa4 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/DeclaredSymbolInfo.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/DeclaredSymbolInfo.cs
@@ -188,7 +188,15 @@ public ISymbol TryResolve(SemanticModel semanticModel, CancellationToken cancell
 $@"Invalid span in {nameof(DeclaredSymbolInfo)}.
 {nameof(this.Span)} = {this.Span}
 {nameof(root.FullSpan)} = {root.FullSpan}";
-                FatalError.ReportWithoutCrash(new InvalidOperationException(message));
+
+                try
+                {
+                    throw new InvalidOperationException(message);
+                }
+                catch (InvalidOperationException e) when (FatalError.ReportWithoutCrash(e))
+                {
+                }
+
                 return null;
             }
         }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex_Create.cs b/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex_Create.cs
index 376ea7aa56007..b2ad099a71c6e 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex_Create.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex_Create.cs
@@ -88,7 +88,14 @@ private static async Task<SyntaxTreeIndex> CreateInfoAsync(Document document, Ca
 $@"Invalid span in {nameof(declaredSymbolInfo)}.
 {nameof(declaredSymbolInfo.Span)} = {declaredSymbolInfo.Span}
 {nameof(root.FullSpan)} = {root.FullSpan}";
-                                    FatalError.ReportWithoutCrash(new InvalidOperationException(message));
+
+                                    try
+                                    {
+                                        throw new InvalidOperationException(message);
+                                    }
+                                    catch (InvalidOperationException e) when (FatalError.ReportWithoutCrash(e))
+                                    {
+                                    }
                                 }
                             }
                         }

From ea6bb946691d558689eb32749a26bc9f63ee04ae Mon Sep 17 00:00:00 2001
From: Tom Meschter <tom.meschter@microsoft.com>
Date: Fri, 14 Apr 2017 13:27:33 -0700
Subject: [PATCH 021/284] Make sure non-fatal exceptions have been thrown

We have the `FatalError.ReportWithoutCrash` method for reporting
non-fatal exceptions. There have been cases where this method is passed
a new, unthrown exception. These exceptions won't have a stack trace,
which makes the resulting telemetry and Watson reports more or less
useless.

Here we check if the exception has a trace, and if it doesn't we simply
throw and catch it before reporting it. This will generally be good
enough, on the assumption that the underlying error occurred (and thus
the exception created) near the call to `ReportWithoutCrash`.
---
 .../Portable/InternalUtilities/FatalError.cs     | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs b/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
index 21ed2ec0e0cb3..966321dde88d9 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
@@ -138,6 +138,22 @@ public static bool Report(Exception exception)
         [DebuggerHidden]
         public static bool ReportWithoutCrash(Exception exception)
         {
+            // There have been cases where a new, unthrown exception has been passed to this method.
+            // In these cases the exception won't have a stack trace, which isn't very helpful. We
+            // throw and catch the exception here as that will result in a stack trace that is
+            // better than nothing.
+            if (exception.StackTrace == null)
+            {
+                try
+                {
+                    throw exception;
+                }
+                catch
+                {
+                    // Empty; we just need the exception to have a stack trace.
+                }
+            }
+
             Report(exception, s_nonFatalHandler);
             return true;
         }

From db8b8e9ad3a73e229f5fcb75df2559cc898663e2 Mon Sep 17 00:00:00 2001
From: Tom Meschter <tom.meschter@microsoft.com>
Date: Mon, 24 Apr 2017 14:31:18 -0700
Subject: [PATCH 022/284] Remove unnecessary try/catches

Now that `FatalError.ReportWithoutCrash` throws and catches unthrown
exceptions itself there is no need to do this at every call site.
---
 .../Portable/InternalUtilities/FatalError.cs     |  7 ++++++-
 .../Preview/DifferenceViewerPreview.cs           |  8 +-------
 .../SymbolSearchUpdateEngine.Update.cs           | 16 ++--------------
 ...cIncrementalAnalyzer_GetDiagnosticsForSpan.cs |  8 +-------
 ...ientServiceFactory.RemoteHostClientService.cs |  8 +-------
 .../IVsEditorAdaptersFactoryServiceExtensions.cs |  8 +-------
 .../Portable/FindSymbols/DeclaredSymbolInfo.cs   |  8 +-------
 .../SyntaxTree/SyntaxTreeIndex_Create.cs         |  8 +-------
 8 files changed, 14 insertions(+), 57 deletions(-)

diff --git a/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs b/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
index 966321dde88d9..a2c8d6028893c 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
@@ -131,8 +131,13 @@ public static bool Report(Exception exception)
         }
 
         /// <summary>
-        /// Use in an exception filter to report a non fatal error.
+        /// Report a non-fatal error.
         /// Calls <see cref="NonFatalHandler"/> and doesn't pass the exception through (the method returns true).
+        /// This is generally expected to be used within an exception filter as that allows us to
+        /// capture data at the point the exception is thrown rather than when it is handled.
+        /// However, it can also be used outside of an exception filter. If the exception has not
+        /// already been thrown the method will throw and catch it itself to ensure we get a useful
+        /// stack trace.
         /// </summary>
         /// <returns>True to catch the exception.</returns>
         [DebuggerHidden]
diff --git a/src/EditorFeatures/Core/Implementation/Preview/DifferenceViewerPreview.cs b/src/EditorFeatures/Core/Implementation/Preview/DifferenceViewerPreview.cs
index 21a4d20ef56a9..488e64fd63437 100644
--- a/src/EditorFeatures/Core/Implementation/Preview/DifferenceViewerPreview.cs
+++ b/src/EditorFeatures/Core/Implementation/Preview/DifferenceViewerPreview.cs
@@ -41,13 +41,7 @@ public void Dispose()
                 return;
             }
 
-            try
-            {
-                throw new Exception($"Dispose is not called how? viewer state : {_viewer.IsClosed}");
-            }
-            catch (Exception e) when (FatalError.ReportWithoutCrash(e))
-            {
-            }
+            FatalError.ReportWithoutCrash(new Exception($"Dispose is not called how? viewer state : {_viewer.IsClosed}"));
         }
     }
 }
\ No newline at end of file
diff --git a/src/EditorFeatures/Core/SymbolSearch/SymbolSearchUpdateEngine.Update.cs b/src/EditorFeatures/Core/SymbolSearch/SymbolSearchUpdateEngine.Update.cs
index 1033192212910..05bba13ca17c3 100644
--- a/src/EditorFeatures/Core/SymbolSearch/SymbolSearchUpdateEngine.Update.cs
+++ b/src/EditorFeatures/Core/SymbolSearch/SymbolSearchUpdateEngine.Update.cs
@@ -586,13 +586,7 @@ private async Task<ValueTuple<bool, byte[]>> TryParseDatabaseElementAsync(XEleme
                 var contentsAttribute = element.Attribute(ContentAttributeName);
                 if (contentsAttribute == null)
                 {
-                    try
-                    {
-                        throw new FormatException($"Database element invalid. Missing '{ContentAttributeName}' attribute");
-                    }
-                    catch (FormatException e) when (_service._reportAndSwallowException(e))
-                    {
-                    }
+                    _service._reportAndSwallowException(new FormatException($"Database element invalid. Missing '{ContentAttributeName}' attribute"));
 
                     return ValueTuple.Create(false, (byte[])null);
                 }
@@ -611,13 +605,7 @@ private async Task<ValueTuple<bool, byte[]>> TryParseDatabaseElementAsync(XEleme
 
                     if (!StringComparer.Ordinal.Equals(expectedChecksum, actualChecksum))
                     {
-                        try
-                        {
-                            throw new FormatException($"Checksum mismatch: expected != actual. {expectedChecksum} != {actualChecksum}");
-                        }
-                        catch (FormatException e) when (_service._reportAndSwallowException(e))
-                        {
-                        }
+                        _service._reportAndSwallowException(new FormatException($"Checksum mismatch: expected != actual. {expectedChecksum} != {actualChecksum}"));
 
                         return ValueTuple.Create(false, (byte[])null);
                     }
diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs
index 2377e4d1dde03..f183ebfde0bc6 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs
@@ -232,13 +232,7 @@ private void VerifyDiagnostics(SemanticModel model)
                 if (!AreEquivalent(rangeDiagnostics, wholeDiagnostics))
                 {
                     // otherwise, report non-fatal watson so that we can fix those cases
-                    try
-                    {
-                        throw new Exception("Bug in GetDiagnostics");
-                    }
-                    catch (Exception e) when (FatalError.ReportWithoutCrash(e))
-                    {
-                    }
+                    FatalError.ReportWithoutCrash(new Exception("Bug in GetDiagnostics"));
 
                     // make sure we hold onto these for debugging.
                     GC.KeepAlive(rangeDeclaractionDiagnostics);
diff --git a/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs b/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs
index 1adee03e9c3ba..be22435e65026 100644
--- a/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs
@@ -248,13 +248,7 @@ private void OnConnectionChanged(object sender, bool connected)
 
                     // s_lastRemoteClientTask info should be saved in the dump
                     // report NFW when connection is closed unless it is proper shutdown
-                    try
-                    {
-                        throw new Exception("Connection to remote host closed");
-                    }
-                    catch (Exception e) when (FatalError.ReportWithoutCrash(e))
-                    {
-                    }
+                    FatalError.ReportWithoutCrash(new Exception("Connection to remote host closed"));
 
                     // use info bar to show warning to users
                     var infoBarUIs = new List<ErrorReportingUI>();
diff --git a/src/VisualStudio/Core/Def/Utilities/IVsEditorAdaptersFactoryServiceExtensions.cs b/src/VisualStudio/Core/Def/Utilities/IVsEditorAdaptersFactoryServiceExtensions.cs
index 4160826763987..d849297702205 100644
--- a/src/VisualStudio/Core/Def/Utilities/IVsEditorAdaptersFactoryServiceExtensions.cs
+++ b/src/VisualStudio/Core/Def/Utilities/IVsEditorAdaptersFactoryServiceExtensions.cs
@@ -31,13 +31,7 @@ public static IOleUndoManager TryGetUndoManager(
                     ? $"{nameof(contextDocumentId)} was null."
                     : $"{nameof(contextDocumentId)} was not null.";
 
-                try
-                {
-                    throw new InvalidOperationException("Could not retrieve document. " + message);
-                }
-                catch(InvalidOperationException e) when (FatalError.ReportWithoutCrash(e))
-                {
-                }
+                FatalError.ReportWithoutCrash(new InvalidOperationException("Could not retrieve document. " + message));
 
                 return null;
             }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/DeclaredSymbolInfo.cs b/src/Workspaces/Core/Portable/FindSymbols/DeclaredSymbolInfo.cs
index 253e34c9bbaa4..ce5f3adb3a451 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/DeclaredSymbolInfo.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/DeclaredSymbolInfo.cs
@@ -189,13 +189,7 @@ public ISymbol TryResolve(SemanticModel semanticModel, CancellationToken cancell
 {nameof(this.Span)} = {this.Span}
 {nameof(root.FullSpan)} = {root.FullSpan}";
 
-                try
-                {
-                    throw new InvalidOperationException(message);
-                }
-                catch (InvalidOperationException e) when (FatalError.ReportWithoutCrash(e))
-                {
-                }
+                FatalError.ReportWithoutCrash(new InvalidOperationException(message));
 
                 return null;
             }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex_Create.cs b/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex_Create.cs
index b2ad099a71c6e..ce8aa6bbaba60 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex_Create.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SyntaxTree/SyntaxTreeIndex_Create.cs
@@ -89,13 +89,7 @@ private static async Task<SyntaxTreeIndex> CreateInfoAsync(Document document, Ca
 {nameof(declaredSymbolInfo.Span)} = {declaredSymbolInfo.Span}
 {nameof(root.FullSpan)} = {root.FullSpan}";
 
-                                    try
-                                    {
-                                        throw new InvalidOperationException(message);
-                                    }
-                                    catch (InvalidOperationException e) when (FatalError.ReportWithoutCrash(e))
-                                    {
-                                    }
+                                    FatalError.ReportWithoutCrash(new InvalidOperationException(message));
                                 }
                             }
                         }

From 05391555f1fa8a74b1c78d7f92bacb6b401067d2 Mon Sep 17 00:00:00 2001
From: Ty Overby <ty@pre-alpha.com>
Date: Fri, 28 Apr 2017 09:08:53 -0700
Subject: [PATCH 023/284] Async main codegen (#18472)

* attempt to get main entrypoints working

* async main codegen

* remove garbage file

* fix vb tests

* add some comments

* moduleBeingBuilt can sometimes be null apparently

* fix style nits

* more whitespace fixes

* address feedback

* automated style fixer

* move most work out into the constructor

* protect against null in error condition

* add comment

* address cston review

* autoformat

* use cast

* check module being built

* add another object cast

* address review

* check for old cases where async methods called Main also exist

* more suggestions

* autoformat

* mostly cleanup

* use shorter Count and Single

* remove superfluous diagnostics add

* check exit code / revert to old entrypoint finding code

* remove language version check in entrypoint compiler

* fix debug.assert

* switch to assert equal

* codereview

* add more tests; change conditions for test execution

* fix up emit methods

* narrow down error location

* ammend GetAwaitableExpressionInfo to return a bound call to GetAwaiter().GetResult()

* more comments

* find entrypoint methods uses the async binder

* autoformat

* use diagnostics from async binder

* relocate tests

* fix suggestions for review 8346

* add back no-async tests with better location

* only allow named types

* remove empty file; remove null checks from helper

* forgot to add csproj file

* emit into warning diagnostics instead of regular diagnostics

* autoformat

* remove unused file from merge

* use diagnostic locations

* move some methods around, split some tests up

* fix non-returning async tests, remove bool return from check availability

* add params test

* style and expected output fix

* switch back to null because default emits warnings

* add partial method tests

* fix locations for unix

* better partial syntax tests

* use expected length of 0

* use default length of 0 for expected output

* check implementation symbol
---
 .../CSharp/Portable/Binder/Binder_Await.cs    |  35 +-
 .../Portable/Compilation/CSharpCompilation.cs | 100 +-
 .../Portable/Compiler/MethodCompiler.cs       |  24 +-
 .../CSharp/Portable/Symbols/MethodSymbol.cs   |  86 +-
 .../Symbols/MethodSymbolExtensions.cs         |  15 +
 .../SynthesizedEntryPointSymbol.cs            | 122 ++-
 .../Test/Emit/CSharpCompilerEmitTest.csproj   |   3 +-
 .../Emit/CodeGen/CodeGenAsyncMainTests.cs     | 912 ++++++++++++++++++
 .../Semantic/Semantics/BindingAsyncTests.cs   | 375 -------
 .../Test/Symbol/Symbols/Source/MethodTests.cs | 105 ++
 .../Test/Utilities/CSharp/CSharpTestBase.cs   |   8 +
 .../Utilities/VisualBasic/BasicTestBase.vb    |  31 +
 .../CoreClr/CoreCLRRuntimeEnvironment.cs      |  15 +-
 .../CoreClr/TestExecutionLoadContext.cs       |   6 +-
 .../CodeRuntime/DesktopRuntimeEnvironment.cs  |  28 +-
 .../CodeRuntime/RuntimeAssemblyManager.cs     |   6 +-
 .../CommonTestBase.CompilationVerifier.cs     |  11 +-
 src/Test/Utilities/Portable/CommonTestBase.cs |  12 +-
 .../Compilation/IRuntimeEnvironment.cs        |   2 +-
 19 files changed, 1366 insertions(+), 530 deletions(-)
 create mode 100644 src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMainTests.cs

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Await.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Await.cs
index 371874bcdeae1..61611318c2954 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Await.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Await.cs
@@ -29,7 +29,7 @@ private BoundExpression BindAwait(BoundExpression expression, SyntaxNode node, D
             bool hasErrors =
                 ReportBadAwaitWithoutAsync(node, diagnostics) |
                 ReportBadAwaitContext(node, diagnostics) |
-                !GetAwaitableExpressionInfo(expression, out getAwaiter, out isCompleted, out getResult, node, diagnostics);
+                !GetAwaitableExpressionInfo(expression, out getAwaiter, out isCompleted, out getResult, out _, node, diagnostics);
 
             // Spec 7.7.7.2:
             // The expression await t is classified the same way as the expression (t).GetAwaiter().GetResult(). Thus,
@@ -209,17 +209,19 @@ private bool ReportBadAwaitContext(SyntaxNode node, DiagnosticBag diagnostics)
         /// Finds and validates the required members of an awaitable expression, as described in spec 7.7.7.1.
         /// </summary>
         /// <returns>True if the expression is awaitable; false otherwise.</returns>
-        private bool GetAwaitableExpressionInfo(
+        internal bool GetAwaitableExpressionInfo(
             BoundExpression expression,
             out MethodSymbol getAwaiter,
             out PropertySymbol isCompleted,
             out MethodSymbol getResult,
+            out BoundExpression getAwaiterGetResultCall,
             SyntaxNode node,
             DiagnosticBag diagnostics)
         {
             getAwaiter = null;
             isCompleted = null;
             getResult = null;
+            getAwaiterGetResultCall = null;
 
             if (!ValidateAwaitedExpression(expression, node, diagnostics))
             {
@@ -231,7 +233,8 @@ private bool GetAwaitableExpressionInfo(
                 return true;
             }
 
-            if (!GetGetAwaiterMethod(expression, node, diagnostics, out getAwaiter))
+            BoundExpression getAwaiterCall = null;
+            if (!GetGetAwaiterMethod(expression, node, diagnostics, out getAwaiter, out getAwaiterCall))
             {
                 return false;
             }
@@ -239,7 +242,7 @@ private bool GetAwaitableExpressionInfo(
             TypeSymbol awaiterType = getAwaiter.ReturnType;
             return GetIsCompletedProperty(awaiterType, node, expression.Type, diagnostics, out isCompleted)
                 && AwaiterImplementsINotifyCompletion(awaiterType, node, diagnostics)
-                && GetGetResultMethod(awaiterType, node, expression.Type, diagnostics, out getResult);
+                && GetGetResultMethod(getAwaiterCall, node, expression.Type, diagnostics, out getResult, out getAwaiterGetResultCall);
         }
 
         /// <summary>
@@ -273,19 +276,21 @@ private static bool ValidateAwaitedExpression(BoundExpression expression, Syntax
         /// NOTE: this is an error in the spec.  An extension method of the form
         /// Awaiter&lt;T&gt; GetAwaiter&lt;T&gt;(this Task&lt;T&gt;) may be used.
         /// </remarks>
-        private bool GetGetAwaiterMethod(BoundExpression expression, SyntaxNode node, DiagnosticBag diagnostics, out MethodSymbol getAwaiterMethod)
+        private bool GetGetAwaiterMethod(BoundExpression expression, SyntaxNode node, DiagnosticBag diagnostics, out MethodSymbol getAwaiterMethod, out BoundExpression getAwaiterCall)
         {
             if (expression.Type.SpecialType == SpecialType.System_Void)
             {
                 Error(diagnostics, ErrorCode.ERR_BadAwaitArgVoidCall, node);
                 getAwaiterMethod = null;
+                getAwaiterCall = null;
                 return false;
             }
 
-            var getAwaiterCall = MakeInvocationExpression(node, expression, WellKnownMemberNames.GetAwaiter, ImmutableArray<BoundExpression>.Empty, diagnostics);
+            getAwaiterCall = MakeInvocationExpression(node, expression, WellKnownMemberNames.GetAwaiter, ImmutableArray<BoundExpression>.Empty, diagnostics);
             if (getAwaiterCall.HasAnyErrors) // && !expression.HasAnyErrors?
             {
                 getAwaiterMethod = null;
+                getAwaiterCall = null;
                 return false;
             }
 
@@ -293,6 +298,7 @@ private bool GetGetAwaiterMethod(BoundExpression expression, SyntaxNode node, Di
             {
                 Error(diagnostics, ErrorCode.ERR_BadAwaitArg, node, expression.Type);
                 getAwaiterMethod = null;
+                getAwaiterCall = null;
                 return false;
             }
 
@@ -303,6 +309,7 @@ private bool GetGetAwaiterMethod(BoundExpression expression, SyntaxNode node, Di
             {
                 Error(diagnostics, ErrorCode.ERR_BadAwaitArg, node, expression.Type);
                 getAwaiterMethod = null;
+                getAwaiterCall = null;
                 return false;
             }
 
@@ -383,28 +390,31 @@ private bool AwaiterImplementsINotifyCompletion(TypeSymbol awaiterType, SyntaxNo
         /// Spec 7.7.7.1:
         /// An Awaiter A has an accessible instance method GetResult with no parameters and no type parameters.
         /// </remarks>
-        private bool GetGetResultMethod(TypeSymbol awaiterType, SyntaxNode node, TypeSymbol awaitedExpressionType, DiagnosticBag diagnostics, out MethodSymbol getResultMethod)
+        private bool GetGetResultMethod(BoundExpression awaiterExpression, SyntaxNode node, TypeSymbol awaitedExpressionType, DiagnosticBag diagnostics, out MethodSymbol getResultMethod, out BoundExpression getAwaiterGetResultCall)
         {
-            var receiver = new BoundLiteral(node, ConstantValue.Null, awaiterType);
-            var getResultCall = MakeInvocationExpression(node, receiver, WellKnownMemberNames.GetResult, ImmutableArray<BoundExpression>.Empty, diagnostics);
-            if (getResultCall.HasAnyErrors)
+            var awaiterType = awaiterExpression.Type;
+            getAwaiterGetResultCall = MakeInvocationExpression(node, awaiterExpression, WellKnownMemberNames.GetResult, ImmutableArray<BoundExpression>.Empty, diagnostics);
+            if (getAwaiterGetResultCall.HasAnyErrors)
             {
                 getResultMethod = null;
+                getAwaiterGetResultCall = null;
                 return false;
             }
 
-            if (getResultCall.Kind != BoundKind.Call)
+            if (getAwaiterGetResultCall.Kind != BoundKind.Call)
             {
                 Error(diagnostics, ErrorCode.ERR_NoSuchMember, node, awaiterType, WellKnownMemberNames.GetResult);
                 getResultMethod = null;
+                getAwaiterGetResultCall = null;
                 return false;
             }
 
-            getResultMethod = ((BoundCall)getResultCall).Method;
+            getResultMethod = ((BoundCall)getAwaiterGetResultCall).Method;
             if (getResultMethod.IsExtensionMethod)
             {
                 Error(diagnostics, ErrorCode.ERR_NoSuchMember, node, awaiterType, WellKnownMemberNames.GetResult);
                 getResultMethod = null;
+                getAwaiterGetResultCall = null;
                 return false;
             }
 
@@ -412,6 +422,7 @@ private bool GetGetResultMethod(TypeSymbol awaiterType, SyntaxNode node, TypeSym
             {
                 Error(diagnostics, ErrorCode.ERR_BadAwaiterPattern, node, awaiterType, awaitedExpressionType);
                 getResultMethod = null;
+                getAwaiterGetResultCall = null;
                 return false;
             }
 
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index dc84d30bf09d2..33be4e8231c4d 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
@@ -1457,7 +1457,7 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
                 var viableEntryPoints = ArrayBuilder<MethodSymbol>.GetInstance();
                 foreach (var candidate in entryPointCandidates)
                 {
-                    if (!candidate.HasEntryPointSignature(this))
+                    if (!HasEntryPointSignature(candidate, warnings))
                     {
                         // a single error for partial methods
                         warnings.Add(ErrorCode.WRN_InvalidMainSig, candidate.Locations.First(), candidate);
@@ -1471,10 +1471,13 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
                         continue;
                     }
 
+                    // PROTOTYPE(async-main): CheckFeatureAvailability should be called on non-async methods 
+                    // that return Task or Task<T>
                     if (candidate.IsAsync)
                     {
                         // PROTOTYPE(async-main): Get the diagnostic to point to a smaller syntax piece.
-                        CheckFeatureAvailability(candidate.DeclaringSyntaxReferences.Single().GetSyntax(), MessageID.IDS_FeatureAsyncMain, diagnostics);
+                        // PROTOTYPE(async-main): Switch diagnostics around if the type is not Task or Task<T>
+                        CheckFeatureAvailability(candidate.GetNonNullSyntaxNode(), MessageID.IDS_FeatureAsyncMain, diagnostics);
                     }
 
                     viableEntryPoints.Add(candidate);
@@ -1525,6 +1528,99 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
             }
         }
 
+        internal bool ReturnsAwaitableToVoidOrInt(MethodSymbol method, DiagnosticBag diagnostics)
+        {
+            // Common case optimization
+            if (method.ReturnType.SpecialType == SpecialType.System_Void || method.ReturnType.SpecialType == SpecialType.System_Int32)
+            {
+                return false;
+            }
+
+            if (!(method.ReturnType is NamedTypeSymbol namedType))
+            {
+                return false;
+            }
+
+            // Early bail so we only even check things that are System.Threading.Tasks.Task(<T>)
+            if (!(namedType.ConstructedFrom == GetWellKnownType(WellKnownType.System_Threading_Tasks_Task) ||
+                  namedType.ConstructedFrom == GetWellKnownType(WellKnownType.System_Threading_Tasks_Task_T)))
+            {
+                return false;
+            }
+
+            var syntax = method.ExtractReturnTypeSyntax();
+            var dumbInstance = new BoundLiteral(syntax, ConstantValue.Null, method.ReturnType);
+            // PROTOTYPE(async-main): We might need to adjust the containing member of the binder to be the Main method
+            var binder = GetBinder(syntax);
+            BoundExpression result;
+            var success = binder.GetAwaitableExpressionInfo(dumbInstance, out _, out _, out _, out result, syntax, diagnostics);
+
+            return success &&
+                (result.Type.SpecialType == SpecialType.System_Void || result.Type.SpecialType == SpecialType.System_Int32);
+        }
+
+        /// <summary>
+        /// Checks if the method has an entry point compatible signature, i.e.
+        /// - the return type is either void, int, <see cref="System.Threading.Tasks.Task" />,
+        /// or <see cref="System.Threading.Tasks.Task{T}" /> where T is an int.
+        /// - has either no parameter or a single parameter of type string[]
+        /// </summary>
+        private bool HasEntryPointSignature(MethodSymbol method, DiagnosticBag bag)
+        {
+            if (method.IsVararg)
+            {
+                return false;
+            }
+
+            TypeSymbol returnType = method.ReturnType;
+            bool returnsTaskOrTaskOfInt = false;
+            if (returnType.SpecialType != SpecialType.System_Int32 && returnType.SpecialType != SpecialType.System_Void)
+            {
+                // Never look for ReturnsAwaitableToVoidOrInt on int32 or void
+                returnsTaskOrTaskOfInt = ReturnsAwaitableToVoidOrInt(method, bag);
+                if (!returnsTaskOrTaskOfInt)
+                {
+                    return false;
+                }
+            }
+
+            // Prior to 7.1, async methods were considered to "have the entrypoint signature".
+            // In order to keep back-compat, we need to let these through if compiling using a previous language version.
+            if (!returnsTaskOrTaskOfInt && method.IsAsync && this.LanguageVersion >= LanguageVersion.CSharp7_1)
+            {
+                return false;
+            }
+
+            if (method.RefKind != RefKind.None)
+            {
+                return false;
+            }
+
+            if (method.Parameters.Length == 0)
+            {
+                return true;
+            }
+
+            if (method.Parameters.Length > 1)
+            {
+                return false;
+            }
+
+            if (!method.ParameterRefKinds.IsDefault)
+            {
+                return false;
+            }
+
+            var firstType = method.Parameters[0].Type;
+            if (firstType.TypeKind != TypeKind.Array)
+            {
+                return false;
+            }
+
+            var array = (ArrayTypeSymbol)firstType;
+            return array.IsSZArray && array.ElementType.SpecialType == SpecialType.System_String;
+        }
+
         internal override bool IsUnreferencedAssemblyIdentityDiagnosticCode(int code)
             => code == (int)ErrorCode.ERR_NoTypeDef;
 
diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
index 8daff0363d5a4..ef0557b8635bb 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
@@ -184,6 +184,8 @@ public static void CompileMethodBodies(
             }
         }
 
+        // Returns the MethodSymbol for the assembly entrypoint.  If the user has a Task returning main,
+        // this function returns the synthesized Main MethodSymbol.
         private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModuleBuilder moduleBeingBuilt, bool hasDeclarationErrors, DiagnosticBag diagnostics, CancellationToken cancellationToken)
         {
             var entryPointAndDiagnostics = compilation.GetEntryPointAndDiagnostics(cancellationToken);
@@ -194,9 +196,26 @@ private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModul
 
             Debug.Assert(!entryPointAndDiagnostics.Diagnostics.IsDefault);
             diagnostics.AddRange(entryPointAndDiagnostics.Diagnostics);
-
             var entryPoint = entryPointAndDiagnostics.MethodSymbol;
-            var synthesizedEntryPoint = entryPoint as SynthesizedEntryPointSymbol;
+
+            if ((object)entryPoint == null)
+            {
+                Debug.Assert(entryPointAndDiagnostics.Diagnostics.HasAnyErrors() || !compilation.Options.Errors.IsDefaultOrEmpty);
+                return null;
+            }
+
+            // entryPoint can be a SynthesizedEntryPointSymbol if a script is being compiled.
+            SynthesizedEntryPointSymbol synthesizedEntryPoint = entryPoint as SynthesizedEntryPointSymbol;
+            if ((object)synthesizedEntryPoint == null && compilation.ReturnsAwaitableToVoidOrInt(entryPoint, diagnostics))
+            {
+                synthesizedEntryPoint = new SynthesizedEntryPointSymbol.AsyncForwardEntryPoint(compilation, diagnostics, entryPoint.ContainingType, entryPoint);
+                entryPoint = synthesizedEntryPoint;
+                if ((object)moduleBeingBuilt != null)
+                {
+                    moduleBeingBuilt.AddSynthesizedDefinition(entryPoint.ContainingType, synthesizedEntryPoint);
+                }
+            }
+
             if (((object)synthesizedEntryPoint != null) &&
                 (moduleBeingBuilt != null) &&
                 !hasDeclarationErrors &&
@@ -221,7 +240,6 @@ private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModul
                 moduleBeingBuilt.SetMethodBody(synthesizedEntryPoint, emittedBody);
             }
 
-            Debug.Assert((object)entryPoint != null || entryPointAndDiagnostics.Diagnostics.HasAnyErrors() || !compilation.Options.Errors.IsDefaultOrEmpty);
             return entryPoint;
         }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs
index ef63dda0f2e10..dae263a5acd7f 100644
--- a/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs
@@ -6,6 +6,7 @@
 using System.Diagnostics;
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Symbols;
 using Roslyn.Utilities;
 
@@ -595,91 +596,6 @@ internal bool IsEntryPointCandidate
             get { return IsStatic && Name == WellKnownMemberNames.EntryPointMethodName; }
         }
 
-        /// <summary>
-        /// Checks if the method has an entry point compatible signature, i.e.
-        /// - the return type is either void, int, <see cref="System.Threading.Tasks.Task" />,
-        /// or <see cref="System.Threading.Tasks.Task{T}" /> where T is an int.
-        /// - has either no parameter or a single parameter of type string[]
-        /// </summary>
-        internal bool HasEntryPointSignature(CSharpCompilation compilation)
-        {
-
-            bool IsAsyncMainReturnType(TypeSymbol type)
-            {
-                var namedType = type as NamedTypeSymbol;
-                if (namedType == null)
-                {
-                    return false;
-                }
-                else if (namedType.ConstructedFrom == compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_Task))
-                {
-                    // Change this to `namedType.IsNonGenericTaskType` if you want to support "task-like" objects.
-                    return true;
-                }
-                else if (namedType.ConstructedFrom == compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_Task_T))
-                {
-                    // Change this to `namedType.IsGenericTaskType` if you want to support "task-like" objects.
-                    return namedType.TypeArguments[0].SpecialType == SpecialType.System_Int32;
-                }
-                else
-                {
-                    return false;
-                }
-            }
-
-            if (IsVararg)
-            {
-                return false;
-            }
-
-            TypeSymbol returnType = ReturnType;
-            bool isAsyncMainReturnType = IsAsyncMainReturnType(returnType);
-            if (returnType.SpecialType != SpecialType.System_Int32 && returnType.SpecialType != SpecialType.System_Void && !isAsyncMainReturnType)
-            {
-                return false;
-            }
-
-            // Prior to 7.1, async methods were considered to "have the entrypoint signature".
-            // In order to keep back-compat, we need to let these through if compiling using a previous language version.
-            if (!isAsyncMainReturnType && IsAsync && compilation.LanguageVersion >= LanguageVersion.CSharp7_1)
-            {
-                return false;
-            }
-
-            if (RefKind != RefKind.None)
-            {
-                return false;
-            }
-
-            if (RefKind != RefKind.None)
-            {
-                return false;
-            }
-
-            if (Parameters.Length == 0)
-            {
-                return true;
-            }
-
-            if (Parameters.Length > 1)
-            {
-                return false;
-            }
-
-            if (!ParameterRefKinds.IsDefault)
-            {
-                return false;
-            }
-
-            var firstType = Parameters[0].Type;
-            if (firstType.TypeKind != TypeKind.Array)
-            {
-                return false;
-            }
-
-            var array = (ArrayTypeSymbol)firstType;
-            return array.IsSZArray && array.ElementType.SpecialType == SpecialType.System_String;
-        }
 
         internal override TResult Accept<TArgument, TResult>(CSharpSymbolVisitor<TArgument, TResult> visitor, TArgument argument)
         {
diff --git a/src/Compilers/CSharp/Portable/Symbols/MethodSymbolExtensions.cs b/src/Compilers/CSharp/Portable/Symbols/MethodSymbolExtensions.cs
index a651f6f1b3a9e..8924222d9878d 100644
--- a/src/Compilers/CSharp/Portable/Symbols/MethodSymbolExtensions.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/MethodSymbolExtensions.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -300,5 +301,19 @@ public static bool IsGenericTaskReturningAsync(this MethodSymbol method, CSharpC
             return method.IsAsync
                 && method.ReturnType.IsGenericTaskType(compilation);
         }
+
+        internal static CSharpSyntaxNode ExtractReturnTypeSyntax(this MethodSymbol method)
+        {
+            method = method.PartialDefinitionPart ?? method;
+            foreach (var reference in method.DeclaringSyntaxReferences)
+            {
+                if (reference.GetSyntax() is MethodDeclarationSyntax methodDeclaration)
+                {
+                    return methodDeclaration.ReturnType;
+                }
+            }
+
+            return (CSharpSyntaxNode)CSharpSyntaxTree.Dummy.GetRoot();
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
index 1d45cc848a95f..58187a5827b59 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
@@ -1,9 +1,11 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
@@ -17,7 +19,8 @@ internal abstract class SynthesizedEntryPointSymbol : MethodSymbol
         internal const string FactoryName = "<Factory>";
 
         private readonly NamedTypeSymbol _containingType;
-        private readonly TypeSymbol _returnType;
+        // PROTOTYPE(async-main): remove this and move it out into inheriting classes?
+        private TypeSymbol _returnType;
 
         internal static SynthesizedEntryPointSymbol Create(SynthesizedInteractiveInitializerMethod initializerMethod, DiagnosticBag diagnostics)
         {
@@ -54,10 +57,9 @@ internal static SynthesizedEntryPointSymbol Create(SynthesizedInteractiveInitial
             }
         }
 
-        private SynthesizedEntryPointSymbol(NamedTypeSymbol containingType, TypeSymbol returnType)
+        private SynthesizedEntryPointSymbol(NamedTypeSymbol containingType, TypeSymbol returnType = null)
         {
             Debug.Assert((object)containingType != null);
-            Debug.Assert((object)returnType != null);
 
             _containingType = containingType;
             _returnType = returnType;
@@ -286,7 +288,7 @@ internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree l
             throw ExceptionUtilities.Unreachable;
         }
 
-        private CSharpSyntaxNode GetSyntax()
+        private static CSharpSyntaxNode DummySyntax()
         {
             var syntaxTree = CSharpSyntaxTree.Dummy;
             return (CSharpSyntaxNode)syntaxTree.GetRoot();
@@ -329,6 +331,104 @@ private static BoundCall CreateParameterlessCall(CSharpSyntaxNode syntax, BoundE
             { WasCompilerGenerated = true };
         }
 
+        /// <summary> A synthesized entrypoint that forwards all calls to an async Main Method </summary>
+        internal sealed class AsyncForwardEntryPoint : SynthesizedEntryPointSymbol
+        {
+            /// <summary> The user-defined asynchronous main method. </summary>
+            private readonly CSharpSyntaxNode _userMainReturnTypeSyntax;
+
+            private readonly BoundExpression _getAwaiterGetResultCall;
+
+            private readonly ImmutableArray<ParameterSymbol> _parameters;
+
+            internal AsyncForwardEntryPoint(CSharpCompilation compilation, DiagnosticBag diagnosticBag, NamedTypeSymbol containingType, MethodSymbol userMain) :
+                base(containingType)
+            {
+                // There should be no way for a userMain to be passed in unless it already passed the 
+                // parameter checks for determining entrypoint validity.
+                Debug.Assert(userMain.ParameterCount == 0 || userMain.ParameterCount == 1);
+
+                _userMainReturnTypeSyntax = userMain.ExtractReturnTypeSyntax();
+                // PROTOTYPE(async-main): we might need to adjust the containing member of the binder to be the Main method.
+                var binder = compilation.GetBinder(_userMainReturnTypeSyntax);
+                _parameters = SynthesizedParameterSymbol.DeriveParameters(userMain, this);
+
+                var arguments = Parameters.SelectAsArray((p, s) => (BoundExpression)new BoundParameter(s, p, p.Type), _userMainReturnTypeSyntax);
+
+                // Main(args) or Main()
+                BoundCall userMainInvocation = new BoundCall(
+                        syntax: _userMainReturnTypeSyntax,
+                        receiverOpt: null,
+                        method: userMain,
+                        arguments: arguments,
+                        argumentNamesOpt: default(ImmutableArray<string>),
+                        argumentRefKindsOpt: default(ImmutableArray<RefKind>),
+                        isDelegateCall: false,
+                        expanded: false,
+                        invokedAsExtensionMethod: false,
+                        argsToParamsOpt: default(ImmutableArray<int>),
+                        resultKind: LookupResultKind.Viable,
+                        type: userMain.ReturnType)
+                { WasCompilerGenerated = true };
+
+                // PROTOTYPE(async-main): lower the tree.
+                var success = binder.GetAwaitableExpressionInfo(userMainInvocation, out _, out _, out _, out _getAwaiterGetResultCall, _userMainReturnTypeSyntax, diagnosticBag);
+                _returnType = _getAwaiterGetResultCall.Type;
+
+                Debug.Assert(
+                    ReturnType.SpecialType == SpecialType.System_Void ||
+                    ReturnType.SpecialType == SpecialType.System_Int32);
+            }
+
+            public override string Name => MainName;
+
+            public override ImmutableArray<ParameterSymbol> Parameters => _parameters;
+
+            internal override BoundBlock CreateBody()
+            {
+                var syntax = _userMainReturnTypeSyntax;
+
+
+                if (ReturnsVoid)
+                {
+                    return new BoundBlock(
+                        syntax: syntax,
+                        locals: ImmutableArray<LocalSymbol>.Empty,
+                        statements: ImmutableArray.Create<BoundStatement>(
+                            new BoundExpressionStatement(
+                                syntax: syntax,
+                                expression: _getAwaiterGetResultCall
+                            )
+                            { WasCompilerGenerated = true },
+                            new BoundReturnStatement(
+                                syntax: syntax,
+                                refKind: RefKind.None,
+                                expressionOpt: null
+                            )
+                            { WasCompilerGenerated = true }
+                        )
+                    )
+                    { WasCompilerGenerated = true };
+
+                }
+                else
+                {
+                    return new BoundBlock(
+                        syntax: syntax,
+                        locals: ImmutableArray<LocalSymbol>.Empty,
+                        statements: ImmutableArray.Create<BoundStatement>(
+                            new BoundReturnStatement(
+                                syntax: syntax,
+                                refKind: RefKind.None,
+                                expressionOpt: _getAwaiterGetResultCall
+                            )
+                        )
+                    )
+                    { WasCompilerGenerated = true };
+                }
+            }
+        }
+
         private sealed class ScriptEntryPoint : SynthesizedEntryPointSymbol
         {
             private readonly MethodSymbol _getAwaiterMethod;
@@ -344,15 +444,9 @@ internal ScriptEntryPoint(NamedTypeSymbol containingType, TypeSymbol returnType,
                 _getResultMethod = getResultMethod;
             }
 
-            public override string Name
-            {
-                get { return MainName; }
-            }
+            public override string Name => MainName;
 
-            public override ImmutableArray<ParameterSymbol> Parameters
-            {
-                get { return ImmutableArray<ParameterSymbol>.Empty; }
-            }
+            public override ImmutableArray<ParameterSymbol> Parameters => ImmutableArray<ParameterSymbol>.Empty;
 
             // private static void <Main>()
             // {
@@ -365,7 +459,7 @@ internal override BoundBlock CreateBody()
                 Debug.Assert((object)_getAwaiterMethod != null);
                 Debug.Assert((object)_getResultMethod != null);
 
-                var syntax = this.GetSyntax();
+                var syntax = DummySyntax();
 
                 var ctor = _containingType.GetScriptConstructor();
                 Debug.Assert(ctor.ParameterCount == 0);
@@ -449,7 +543,7 @@ public override ImmutableArray<ParameterSymbol> Parameters
             // }
             internal override BoundBlock CreateBody()
             {
-                var syntax = this.GetSyntax();
+                var syntax = DummySyntax();
 
                 var ctor = _containingType.GetScriptConstructor();
                 Debug.Assert(ctor.ParameterCount == 1);
diff --git a/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj b/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj
index 55b77172ef679..5d82edc5b9f06 100644
--- a/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj
+++ b/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj
@@ -67,6 +67,7 @@
     <Compile Include="Attributes\AttributeTests_Synthesized.cs" />
     <Compile Include="Attributes\AttributeTests_Tuples.cs" />
     <Compile Include="Attributes\AttributeTests_WellKnownAttributes.cs" />
+    <Compile Include="CodeGen\CodeGenAsyncMainTests.cs" />
     <Compile Include="CodeGen\CodeGenCapturing.cs" />
     <Compile Include="Emit\BinaryCompatibility.cs" />
     <Compile Include="Emit\DesktopStrongNameProviderTests.cs" />
@@ -190,4 +191,4 @@
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <Import Project="..\..\..\..\..\build\Targets\Imports.targets" />
-</Project>
+</Project>
\ No newline at end of file
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMainTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMainTests.cs
new file mode 100644
index 0000000000000..3dd02d4548495
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMainTests.cs
@@ -0,0 +1,912 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Xunit;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests.CodeGen
+{
+    public class CodeGenAsyncMainTests : EmitMetadataTestBase
+    {
+
+        [Fact]
+        public void MultipleMainsOneOfWhichHasBadTaskType_WithMainType()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+namespace System.Threading.Tasks {
+    public class Task<T> {
+        public void GetAwaiter() {}
+    }
+}
+
+static class Program {
+    static Task<int> Main() {
+        return null;
+    }
+    static void Main(string[] args) { }
+}";
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe.WithMainTypeName("Program"), parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            sourceCompilation.VerifyEmitDiagnostics(
+                // (11,12): warning CS0436: The type 'Task<T>' in '' conflicts with the imported type 'Task<TResult>' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task<int>").WithArguments("", "System.Threading.Tasks.Task<T>", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task<TResult>").WithLocation(11, 12));
+        }
+
+        [Fact]
+        public void MultipleMainsOneOfWhichHasBadTaskType()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+namespace System.Threading.Tasks {
+    public class Task<T> {
+        public void GetAwaiter() {}
+    }
+}
+
+static class Program {
+    static Task<int> Main() {
+        return null;
+    }
+    static void Main(string[] args) { }
+}";
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            sourceCompilation.VerifyEmitDiagnostics(
+                // (11,12): warning CS0436: The type 'Task<T>' in '' conflicts with the imported type 'Task<TResult>' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task<int>").WithArguments("", "System.Threading.Tasks.Task<T>", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task<TResult>").WithLocation(11, 12),
+                // (11,12): error CS1986: 'await' requires that the type Task<int> have a suitable GetAwaiter method
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.ERR_BadAwaitArg, "Task<int>").WithArguments("System.Threading.Tasks.Task<int>").WithLocation(11, 12),
+                // (11,22): warning CS0028: 'Program.Main()' has the wrong signature to be an entry point
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main()").WithLocation(11, 22));
+        }
+
+        [Fact]
+        public void GetResultReturnsSomethingElse()
+        {
+            var source = @"
+using System.Threading.Tasks;
+using System;
+
+namespace System.Runtime.CompilerServices {
+    public interface INotifyCompletion {
+        void OnCompleted(Action action);
+    }
+}
+
+namespace System.Threading.Tasks {
+    public class Awaiter: System.Runtime.CompilerServices.INotifyCompletion {
+        public double GetResult() { return 0.0; }
+        public bool IsCompleted  => true;
+        public void OnCompleted(Action action) {}
+    }
+    public class Task<T> {
+        public Awaiter GetAwaiter() {
+            return new Awaiter();
+        }
+    }
+}
+
+static class Program {
+    static Task<int> Main() {
+        return null;
+    }
+}";
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            sourceCompilation.VerifyEmitDiagnostics(
+                // (25,12): warning CS0436: The type 'Task<T>' in '' conflicts with the imported type 'Task<TResult>' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task<int>").WithArguments("", "System.Threading.Tasks.Task<T>", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task<TResult>").WithLocation(25, 12),
+                // (25,22): warning CS0028: 'Program.Main()' has the wrong signature to be an entry point
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main()").WithLocation(25, 22),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1)
+);
+        }
+
+        [Fact]
+        public void TaskOfTGetAwaiterReturnsVoid()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+namespace System.Threading.Tasks {
+    public class Task<T> {
+        public void GetAwaiter() {}
+    }
+}
+
+static class Program {
+    static Task<int> Main() {
+        return null;
+    }
+}";
+
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            sourceCompilation.VerifyDiagnostics(
+                // (12,12): warning CS0436: The type 'Task<T>' in '' conflicts with the imported type 'Task<TResult>' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task<int>").WithArguments("", "System.Threading.Tasks.Task<T>", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task<TResult>").WithLocation(12, 12),
+                // (12,12): error CS1986: 'await' requires that the type Task<int> have a suitable GetAwaiter method
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.ERR_BadAwaitArg, "Task<int>").WithArguments("System.Threading.Tasks.Task<int>").WithLocation(12, 12),
+                // (12,22): warning CS0028: 'Program.Main()' has the wrong signature to be an entry point
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main()").WithLocation(12, 22),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1),
+                // (2,1): hidden CS8019: Unnecessary using directive.
+                // using System;
+                Diagnostic(ErrorCode.HDN_UnusedUsingDirective, "using System;").WithLocation(2, 1));
+        }
+        [Fact]
+        public void TaskGetAwaiterReturnsVoid()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+namespace System.Threading.Tasks {
+    public class Task {
+        public void GetAwaiter() {}
+    }
+}
+
+static class Program {
+    static Task Main() {
+        return null;
+    }
+}";
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            sourceCompilation.VerifyEmitDiagnostics(
+                // (12,12): warning CS0436: The type 'Task' in '' conflicts with the imported type 'Task' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     static Task Main() {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task").WithArguments("", "System.Threading.Tasks.Task", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task").WithLocation(12, 12),
+                // (12,12): error CS1986: 'await' requires that the type Task have a suitable GetAwaiter method
+                //     static Task Main() {
+                Diagnostic(ErrorCode.ERR_BadAwaitArg, "Task").WithArguments("System.Threading.Tasks.Task").WithLocation(12, 12),
+                // (12,17): warning CS0028: 'Program.Main()' has the wrong signature to be an entry point
+                //     static Task Main() {
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main()").WithLocation(12, 17),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void MissingMethodsOnTask()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+namespace System.Threading.Tasks {
+    public class Task {}
+}
+
+static class Program {
+    static Task Main() {
+        return null;
+    }
+}";
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            sourceCompilation.VerifyEmitDiagnostics(
+                // (10,12): warning CS0436: The type 'Task' in '' conflicts with the imported type 'Task' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     static Task Main() {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task").WithArguments("", "System.Threading.Tasks.Task", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task").WithLocation(10, 12),
+                // (10,12): error CS1061: 'Task' does not contain a definition for 'GetAwaiter' and no extension method 'GetAwaiter' accepting a first argument of type 'Task' could be found (are you missing a using directive or an assembly reference?)
+                //     static Task Main() {
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "Task").WithArguments("System.Threading.Tasks.Task", "GetAwaiter").WithLocation(10, 12),
+                // (10,17): warning CS0028: 'Program.Main()' has the wrong signature to be an entry point
+                //     static Task Main() {
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main()").WithLocation(10, 17),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void EmitTaskOfIntReturningMainWithoutInt()
+        {
+            var corAssembly = @"
+namespace System {
+    public class Object {}
+}";
+            var corCompilation = CreateCompilation(corAssembly, options: TestOptions.DebugDll);
+            corCompilation.VerifyDiagnostics();
+
+            var taskAssembly = @"
+namespace System.Threading.Tasks {
+    public class Task<T>{}
+}";
+            var taskCompilation = CreateCompilationWithMscorlib45(taskAssembly, options: TestOptions.DebugDll);
+            taskCompilation.VerifyDiagnostics();
+
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+static class Program {
+    static Task<int> Main() {
+        return null;
+    }
+}";
+            var sourceCompilation = CreateCompilation(source, new[] { corCompilation.ToMetadataReference(), taskCompilation.ToMetadataReference() }, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            sourceCompilation.VerifyEmitDiagnostics(
+                // warning CS8021: No value for RuntimeMetadataVersion found. No assembly containing System.Object was found nor was a value for RuntimeMetadataVersion specified through options.
+                Diagnostic(ErrorCode.WRN_NoRuntimeMetadataVersion).WithLocation(1, 1),
+                // (6,17): error CS0518: Predefined type 'System.Int32' is not defined or imported
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "int").WithArguments("System.Int32").WithLocation(6, 17),
+                // (6,12): error CS1061: 'Task<int>' does not contain a definition for 'GetAwaiter' and no extension method 'GetAwaiter' accepting a first argument of type 'Task<int>' could be found (are you missing a using directive or an assembly reference?)
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "Task<int>").WithArguments("System.Threading.Tasks.Task<int>", "GetAwaiter").WithLocation(6, 12),
+                // (6,22): warning CS0028: 'Program.Main()' has the wrong signature to be an entry point
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main()").WithLocation(6, 22),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void EmitTaskReturningMainWithoutVoid()
+        {
+            var corAssembly = @"
+namespace System {
+    public class Object {}
+}";
+            var corCompilation = CreateCompilation(corAssembly, options: TestOptions.DebugDll);
+            corCompilation.VerifyDiagnostics();
+
+            var taskAssembly = @"
+namespace System.Threading.Tasks {
+    public class Task{}
+}";
+            var taskCompilation = CreateCompilationWithMscorlib45(taskAssembly, options: TestOptions.DebugDll);
+            taskCompilation.VerifyDiagnostics();
+
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+static class Program {
+    static Task Main() {
+        return null;
+    }
+}";
+            var sourceCompilation = CreateCompilation(source, new[] { corCompilation.ToMetadataReference(), taskCompilation.ToMetadataReference() }, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            sourceCompilation.VerifyEmitDiagnostics(
+                // warning CS8021: No value for RuntimeMetadataVersion found. No assembly containing System.Object was found nor was a value for RuntimeMetadataVersion specified through options.
+                Diagnostic(ErrorCode.WRN_NoRuntimeMetadataVersion).WithLocation(1, 1),
+                // (6,12): error CS1061: 'Task' does not contain a definition for 'GetAwaiter' and no extension method 'GetAwaiter' accepting a first argument of type 'Task' could be found (are you missing a using directive or an assembly reference?)
+                //     static Task Main() {
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "Task").WithArguments("System.Threading.Tasks.Task", "GetAwaiter").WithLocation(6, 12),
+                // (6,17): warning CS0028: 'Program.Main()' has the wrong signature to be an entry point
+                //     static Task Main() {
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main()").WithLocation(6, 17),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void AsyncEmitMainOfIntTest()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+class Program {
+    static async Task<int> Main() {
+        Console.Write(""hello "");
+        await Task.Factory.StartNew(() => 5);
+        Console.Write(""async main"");
+        return 10;
+    }
+}";
+            var c = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            var verifier = CompileAndVerify(c, expectedOutput: "hello async main", expectedReturnCode: 10);
+
+        }
+
+        [Fact]
+        public void AsyncEmitMainTest()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+class Program {
+    static async Task Main() {
+        Console.Write(""hello "");
+        await Task.Factory.StartNew(() => 5);
+        Console.Write(""async main"");
+    }
+}";
+            var c = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            var verifier = CompileAndVerify(c, expectedOutput: "hello async main", expectedReturnCode: 0);
+        }
+
+        [Fact]
+        public void AsyncMainTestCodegenWithErrors()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+class Program {
+    static async Task<int> Main() {
+        Console.WriteLine(""hello"");
+        await Task.Factory.StartNew(() => 5);
+        Console.WriteLine(""async main"");
+    }
+}";
+            var c = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            c.VerifyEmitDiagnostics(
+                // (6,28): error CS0161: 'Program.Main()': not all code paths return a value
+                //     static async Task<int> Main() {
+                Diagnostic(ErrorCode.ERR_ReturnExpected, "Main").WithArguments("Program.Main()").WithLocation(6, 28));
+        }
+
+
+        [Fact]
+        public void AsyncEmitMainOfIntTest_StringArgs()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+class Program {
+    static async Task<int> Main(string[] args) {
+        Console.Write(""hello "");
+        await Task.Factory.StartNew(() => 5);
+        Console.Write(""async main"");
+        return 10;
+    }
+}";
+            var c = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            var verifier = CompileAndVerify(c, expectedOutput: "hello async main", expectedReturnCode: 10);
+        }
+
+        [Fact]
+        public void AsyncEmitMainOfIntTest_ParamsStringArgs()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+class Program {
+    static async Task<int> Main(params string[] args) {
+        Console.Write(""hello "");
+        await Task.Factory.StartNew(() => 5);
+        Console.Write(""async main"");
+        return 10;
+    }
+}";
+            var c = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            var verifier = CompileAndVerify(c, expectedOutput: "hello async main", expectedReturnCode: 10);
+        }
+
+        [Fact]
+        public void AsyncEmitMainTest_StringArgs()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+class Program {
+    static async Task Main(string[] args) {
+        Console.Write(""hello "");
+        await Task.Factory.StartNew(() => 5);
+        Console.Write(""async main"");
+    }
+}";
+            var c = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            var verifier = CompileAndVerify(c, expectedOutput: "hello async main", expectedReturnCode: 0);
+        }
+
+        [Fact]
+        public void AsyncEmitMainTestCodegenWithErrors_StringArgs()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+class Program {
+    static async Task<int> Main(string[] args) {
+        Console.WriteLine(""hello"");
+        await Task.Factory.StartNew(() => 5);
+        Console.WriteLine(""async main"");
+    }
+}";
+            var c = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            c.VerifyEmitDiagnostics(
+                // (6,28): error CS0161: 'Program.Main()': not all code paths return a value
+                //     static async Task<int> Main() {
+                Diagnostic(ErrorCode.ERR_ReturnExpected, "Main").WithArguments("Program.Main(string[])").WithLocation(6, 28));
+        }
+
+        [Fact]
+        public void AsyncEmitMainOfIntTest_StringArgs_WithArgs()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+class Program {
+    static async Task<int> Main(string[] args) {
+        Console.Write(""hello "");
+        await Task.Factory.StartNew(() => 5);
+        Console.Write(args[0]);
+        return 10;
+    }
+}";
+            var c = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            var verifier = CompileAndVerify(c, expectedOutput: "hello async main", expectedReturnCode: 10, args: new string[] { "async main" });
+        }
+
+        [Fact]
+        public void AsyncEmitMainTest_StringArgs_WithArgs()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+class Program {
+    static async Task Main(string[] args) {
+        Console.Write(""hello "");
+        await Task.Factory.StartNew(() => 5);
+        Console.Write(args[0]);
+    }
+}";
+            var c = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            var verifier = CompileAndVerify(c, expectedOutput: "hello async main", expectedReturnCode: 0, args: new string[] { "async main" });
+        }
+
+        [Fact]
+        public void MainCanBeAsyncWithArgs()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task Main(string[] args)
+    {
+        await Task.Factory.StartNew(() => { });
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics();
+            var entry = compilation.GetEntryPoint(CancellationToken.None);
+            Assert.NotNull(entry);
+            Assert.Equal("System.Threading.Tasks.Task A.Main(System.String[] args)", entry.ToTestDisplayString());
+
+            CompileAndVerify(compilation, expectedReturnCode: 0);
+        }
+
+        [Fact]
+        public void MainCanReturnTaskWithArgs_NoAsync()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static Task Main(string[] args)
+    {
+        return Task.Factory.StartNew(() => { });
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics();
+            var entry = compilation.GetEntryPoint(CancellationToken.None);
+            Assert.NotNull(entry);
+            Assert.Equal("System.Threading.Tasks.Task A.Main(System.String[] args)", entry.ToTestDisplayString());
+
+            CompileAndVerify(compilation, expectedReturnCode: 0);
+        }
+
+
+        [Fact]
+        public void MainCantBeAsyncWithRefTask()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static ref Task Main(string[] args)
+    {
+        throw new System.Exception();
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics(
+                // (6,21): warning CS0028: 'A.Main(string[])' has the wrong signature to be an entry point
+                //     static ref Task Main(string[] args)
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main(string[])").WithLocation(6, 21),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void MainCantBeAsyncWithArgs_CSharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task Main(string[] args)
+    {
+        await Task.Factory.StartNew(() => { });
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            compilation.VerifyDiagnostics(
+                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     async static Task Main(string[] args)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task Main(string[] args)
+    {
+        await Task.Factory.StartNew(() => { });
+    }").WithArguments("async main", "7.1").WithLocation(6, 5));
+        }
+
+        [Fact]
+        public void MainCanReturnTask()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task Main()
+    {
+        await Task.Factory.StartNew(() => { });
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics();
+            var entry = compilation.GetEntryPoint(CancellationToken.None);
+            Assert.NotNull(entry);
+            Assert.Equal("System.Threading.Tasks.Task A.Main()", entry.ToTestDisplayString());
+        }
+        [Fact]
+        public void MainCanReturnTask_NoAsync()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static Task Main()
+    {
+        return Task.Factory.StartNew(() => { });
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics();
+            var entry = compilation.GetEntryPoint(CancellationToken.None);
+            Assert.NotNull(entry);
+            Assert.Equal("System.Threading.Tasks.Task A.Main()", entry.ToTestDisplayString());
+        }
+
+        [Fact]
+        public void MainCantBeAsyncVoid()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static void Main()
+    {
+        await Task.Factory.StartNew(() => { });
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics(
+                // (6,23): warning CS0028: 'A.Main()' has the wrong signature to be an entry point
+                //     async static void Main()
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main()").WithLocation(6, 23),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+            var entry = compilation.GetEntryPoint(CancellationToken.None);
+            Assert.Null(entry);
+        }
+
+        [Fact]
+        public void MainCantBeAsyncVoid_CSharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static void Main()
+    {
+        await Task.Factory.StartNew(() => { });
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            compilation.VerifyDiagnostics(
+            // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+            //     async static void Main()
+            Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static void Main()
+    {
+        await Task.Factory.StartNew(() => { });
+    }").WithArguments("async main", "7.1").WithLocation(6, 5));
+        }
+
+        [Fact]
+        public void MainCantBeAsyncInt()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static int Main()
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics(
+                // (6,22): error CS1983: The return type of an async method must be void, Task or Task<T>
+                //     async static int Main()
+                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "Main").WithLocation(6, 22),
+                // (6,23): warning CS0028: 'A.Main()' has the wrong signature to be an entry point
+                //     async static void Main()
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main()").WithLocation(6, 22),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+            var entry = compilation.GetEntryPoint(CancellationToken.None);
+            Assert.Null(entry);
+        }
+
+        [Fact]
+        public void MainCantBeAsyncInt_CSharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static int Main()
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            compilation.VerifyDiagnostics(
+                // (6,22): error CS1983: The return type of an async method must be void, Task or Task<T>
+                //     async static int Main()
+                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "Main"),
+                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     async static int Main()
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static int Main()
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }").WithArguments("async main", "7.1").WithLocation(6, 5)
+);
+        }
+
+        [Fact]
+        public void MainCanReturnTaskAndGenericOnInt_WithArgs()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task<int> Main(string[] args)
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics();
+            var entry = compilation.GetEntryPoint(CancellationToken.None);
+            Assert.NotNull(entry);
+            Assert.Equal("System.Threading.Tasks.Task<System.Int32> A.Main(System.String[] args)", entry.ToTestDisplayString());
+        }
+
+        [Fact]
+        public void MainCanReturnTaskAndGenericOnInt_WithArgs_NoAsync()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static Task<int> Main(string[] args)
+    {
+        return Task.Factory.StartNew(() => 5);
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics();
+            var entry = compilation.GetEntryPoint(CancellationToken.None);
+            Assert.NotNull(entry);
+            Assert.Equal("System.Threading.Tasks.Task<System.Int32> A.Main(System.String[] args)", entry.ToTestDisplayString());
+        }
+
+        [Fact]
+        public void MainCantBeAsyncAndGenericOnInt_WithArgs_Csharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task<int> Main(string[] args)
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            compilation.VerifyDiagnostics(
+            // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+            //     async static Task<int> Main(string[] args)
+            Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task<int> Main(string[] args)
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }").WithArguments("async main", "7.1").WithLocation(6, 5)
+);
+        }
+
+        [Fact]
+        public void MainCanReturnTaskAndGenericOnInt()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task<int> Main()
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics();
+            var entry = compilation.GetEntryPoint(CancellationToken.None);
+            Assert.NotNull(entry);
+            Assert.Equal("System.Threading.Tasks.Task<System.Int32> A.Main()", entry.ToTestDisplayString());
+        }
+        [Fact]
+        public void MainCanReturnTaskAndGenericOnInt_NoAsync()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static Task<int> Main()
+    {
+        return Task.Factory.StartNew(() => 5);
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics();
+            var entry = compilation.GetEntryPoint(CancellationToken.None);
+            Assert.NotNull(entry);
+            Assert.Equal("System.Threading.Tasks.Task<System.Int32> A.Main()", entry.ToTestDisplayString());
+        }
+
+        [Fact]
+        public void MainCantBeAsyncAndGenericOnInt_CSharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task<int> Main()
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            compilation.VerifyDiagnostics(
+                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     async static Task<int> Main()
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task<int> Main()
+    {
+        return await Task.Factory.StartNew(() => 5);
+    }").WithArguments("async main", "7.1").WithLocation(6, 5)
+                );
+        }
+
+        [Fact]
+        public void MainCantBeAsyncAndGenericOverFloats()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task<float> Main()
+    {
+        await Task.Factory.StartNew(() => { });
+        return 0;
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            compilation.VerifyDiagnostics(
+                // (6,30): warning CS0028: 'A.Main()' has the wrong signature to be an entry point
+                //     async static Task<float> Main()
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main()").WithLocation(6, 30),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void MainCantBeAsync_AndGeneric()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static void Main<T>()
+    {
+        await Task.Factory.StartNew(() => { });
+    }
+}";
+            CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1)).VerifyDiagnostics(
+                // (6,23): warning CS0028: 'A.Main<T>()' has the wrong signature to be an entry point
+                //     async static void Main<T>()
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main<T>()").WithLocation(6, 23),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void MainCantBeAsync_AndBadSig()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static void Main(bool truth)
+    {
+        await Task.Factory.StartNew(() => { });
+    }
+}";
+            CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe).VerifyDiagnostics(
+                // (6,23): warning CS0028: 'A.Main(bool)' has the wrong signature to be an entry point
+                //     async static void Main(bool truth)
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main(bool)").WithLocation(6, 23),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void MainCantBeAsync_AndGeneric_AndBadSig()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static void Main<T>(bool truth)
+    {
+        await Task.Factory.StartNew(() => { });
+    }
+}";
+            CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe).VerifyDiagnostics(
+                // (6,23): warning CS0028: 'A.Main<T>(bool)' has the wrong signature to be an entry point
+                //     async static void Main<T>(bool truth)
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main<T>(bool)").WithLocation(6, 23),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs
index 692b282000480..1860dcfaa6482 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs
@@ -1222,382 +1222,7 @@ interface IInterface
         }
 
         [Fact]
-        public void MainCanBeAsyncWithArgs()
-        {
-            var origSource = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static Task Main(string[] args)
-    {
-        await Task.Factory.StartNew(() => { });
-    }
-}";
-            var sources = new string[] { origSource, origSource.Replace("async ", "").Replace("await", "return") };
-            foreach (var source in sources)
-            {
-                var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
-                compilation.VerifyDiagnostics();
-                var entry = compilation.GetEntryPoint(CancellationToken.None);
-                Assert.NotNull(entry);
-                Assert.Equal("System.Threading.Tasks.Task A.Main(System.String[] args)", entry.ToTestDisplayString());
-            }
-        }
-
-        [Fact]
-        public void MainCantBeAsyncWithRefTask()
-        {
-            var source = @"
-using System.Threading.Tasks;
-
-class A
-{
-    static ref Task Main(string[] args)
-    {
-        throw new System.Exception();
-    }
-}";
-            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
-            compilation.VerifyDiagnostics(
-                // (6,21): warning CS0028: 'A.Main(string[])' has the wrong signature to be an entry point
-                //     static ref Task Main(string[] args)
-                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main(string[])").WithLocation(6, 21),
-                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
-                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
-        }
-
-        [Fact]
-        public void MainCantBeAsyncWithArgs_CSharp7()
-        {
-            var source = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static Task Main(string[] args)
-    {
-        await Task.Factory.StartNew(() => { });
-    }
-}";
-            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
-            compilation.VerifyDiagnostics(
-                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
-                //     async static Task Main(string[] args)
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task Main(string[] args)
-    {
-        await Task.Factory.StartNew(() => { });
-    }").WithArguments("async main", "7.1").WithLocation(6, 5));
-        }
-
-        [Fact]
-        public void MainCanBeAsync()
-        {
-            var origSource = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static Task Main()
-    {
-        await Task.Factory.StartNew(() => { });
-    }
-}";
-            var sources = new string[] { origSource, origSource.Replace("async ", "").Replace("await", "return") };
-            foreach (var source in sources)
-            {
-                var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
-                compilation.VerifyDiagnostics();
-                var entry = compilation.GetEntryPoint(CancellationToken.None);
-                Assert.NotNull(entry);
-                Assert.Equal("System.Threading.Tasks.Task A.Main()", entry.ToTestDisplayString());
-            }
-        }
-
-        [Fact]
-        public void MainCantBeAsyncVoid()
-        {
-            var source = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static void Main()
-    {
-        await Task.Factory.StartNew(() => { });
-    }
-}";
-            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
-            compilation.VerifyDiagnostics(
-                // (6,23): warning CS0028: 'A.Main()' has the wrong signature to be an entry point
-                //     async static void Main()
-                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main()").WithLocation(6, 23),
-                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
-                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
-            var entry = compilation.GetEntryPoint(CancellationToken.None);
-            Assert.Null(entry);
-        }
-
-        [Fact]
-        public void MainCantBeAsyncVoid_CSharp7()
-        {
-            var source = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static void Main()
-    {
-        await Task.Factory.StartNew(() => { });
-    }
-}";
-            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
-            compilation.VerifyDiagnostics(
-                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
-                //     async static void Main()
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static void Main()
-    {
-        await Task.Factory.StartNew(() => { });
-    }").WithArguments("async main", "7.1").WithLocation(6, 5));
-        }
-
-        [Fact]
-        public void MainCantBeAsyncInt()
-        {
-            var source = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static int Main()
-    {
-        return await Task.Factory.StartNew(() => 5);
-    }
-}";
-            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
-            compilation.VerifyDiagnostics(
-                // (6,22): error CS1983: The return type of an async method must be void, Task or Task<T>
-                //     async static int Main()
-                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "Main").WithLocation(6, 22),
-                // (6,23): warning CS0028: 'A.Main()' has the wrong signature to be an entry point
-                //     async static void Main()
-                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main()").WithLocation(6, 22),
-                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
-                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
-            var entry = compilation.GetEntryPoint(CancellationToken.None);
-            Assert.Null(entry);
-        }
-
-        [Fact]
-        public void MainCantBeAsyncInt_CSharp7()
-        {
-            var source = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static int Main()
-    {
-        return await Task.Factory.StartNew(() => 5);
-    }
-}";
-            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
-            compilation.VerifyDiagnostics(
-                // (6,22): error CS1983: The return type of an async method must be void, Task or Task<T>
-                //     async static int Main()
-                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "Main"),
-                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
-                //     async static int Main()
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static int Main()
-    {
-        return await Task.Factory.StartNew(() => 5);
-    }").WithArguments("async main", "7.1").WithLocation(6, 5)
-);
-        }
-
-        [Fact]
-        public void MainCanBeAsyncAndGenericOnIntWithArgs()
-        {
-            var origSource = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static Task<int> Main(string[] args)
-    {
-        return await Task.Factory.StartNew(() => 5);
-    }
-}";
-            var sources = new string[] { origSource, origSource.Replace("async ", "").Replace("await", "") };
-            foreach (var source in sources)
-            {
-                var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
-                compilation.VerifyDiagnostics();
-                var entry = compilation.GetEntryPoint(CancellationToken.None);
-                Assert.NotNull(entry);
-                Assert.Equal("System.Threading.Tasks.Task<System.Int32> A.Main(System.String[] args)", entry.ToTestDisplayString());
-            }
-        }
-
-        [Fact]
-        public void MainCantBeAsyncAndGenericOnIntWithArgs_Csharp7()
-        {
-            var source = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static Task<int> Main(string[] args)
-    {
-        return await Task.Factory.StartNew(() => 5);
-    }
-}";
-                var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
-                compilation.VerifyDiagnostics(
-// (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
-                //     async static Task<int> Main(string[] args)
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task<int> Main(string[] args)
-    {
-        return await Task.Factory.StartNew(() => 5);
-    }").WithArguments("async main", "7.1").WithLocation(6, 5)
-);
-        }
-
-        [Fact]
-        public void MainCanBeAsyncAndGenericOnInt()
-        {
-            var origSource = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static Task<int> Main()
-    {
-        return await Task.Factory.StartNew(() => 5);
-    }
-}";
-            var sources = new string[] { origSource, origSource.Replace("async ", "").Replace("await", "") };
-            foreach (var source in sources)
-            {
-                var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
-                compilation.VerifyDiagnostics();
-                var entry = compilation.GetEntryPoint(CancellationToken.None);
-                Assert.NotNull(entry);
-                Assert.Equal("System.Threading.Tasks.Task<System.Int32> A.Main()", entry.ToTestDisplayString());
-            }
-        }
-
-        [Fact]
-        public void MainCantBeAsyncAndGenericOnInt_CSharp7()
-        {
-            var source = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static Task<int> Main()
-    {
-        return await Task.Factory.StartNew(() => 5);
-    }
-}";
-                var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
-                compilation.VerifyDiagnostics(
-                    // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
-                    //     async static Task<int> Main()
-                    Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task<int> Main()
-    {
-        return await Task.Factory.StartNew(() => 5);
-    }").WithArguments("async main", "7.1").WithLocation(6, 5)
-                    );
-        }
-
-        [Fact]
-        public void MainCantBeAsyncAndGenericOverFloats()
-        {
-            var source = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static Task<float> Main()
-    {
-        await Task.Factory.StartNew(() => { });
-        return 0;
-    }
-}";
-            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
-            compilation.VerifyDiagnostics(
-                // (6,30): warning CS0028: 'A.Main()' has the wrong signature to be an entry point
-                //     async static Task<float> Main()
-                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main()").WithLocation(6, 30),
-                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
-                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1) );
-        }
-
-        [Fact]
-        public void MainCantBeAsync_AndGeneric()
-        {
-            var source = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static void Main<T>()
-    {
-        await Task.Factory.StartNew(() => { });
-    }
-}";
-            CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1)).VerifyDiagnostics(
-                // (4,23): warning CS0402: 'A.Main<T>()': an entry point cannot be generic or in a generic type
-                //     async static void Main<T>()
-                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main<T>()"),
-                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
-                Diagnostic(ErrorCode.ERR_NoEntryPoint));
-        }
 
-        [Fact]
-        public void MainCantBeAsync_AndBadSig()
-        {
-            var source = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static void Main(bool truth)
-    {
-        await Task.Factory.StartNew(() => { });
-    }
-}";
-            CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe).VerifyDiagnostics(
-                // (4,23): warning CS0028: 'A.Main(bool)' has the wrong signature to be an entry point
-                //     async static void Main(bool truth)
-                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main(bool)"),
-                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
-                Diagnostic(ErrorCode.ERR_NoEntryPoint));
-        }
-
-        [Fact]
-        public void MainCantBeAsync_AndGeneric_AndBadSig()
-        {
-            var source = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static void Main<T>(bool truth)
-    {
-        await Task.Factory.StartNew(() => { });
-    }
-}";
-            CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe).VerifyDiagnostics(
-                // (4,23): warning CS0028: 'A.Main<T>(bool)' has the wrong signature to be an entry point
-                //     async static void Main<T>(bool truth)
-                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main<T>(bool)"),
-                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
-                Diagnostic(ErrorCode.ERR_NoEntryPoint));
-        }
-
-        [Fact]
         public void AwaitInQuery_FirstCollectionExpressionOfInitialFrom()
         {
             var source = @"
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/MethodTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/MethodTests.cs
index a0ca5014afd75..e0b17fba31631 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/MethodTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/MethodTests.cs
@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.Text;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Xunit;
@@ -202,6 +203,110 @@ partial void M() {}
             Assert.Equal(1, m.First().Locations.Length);
         }
 
+        [Fact]
+        public void PartialExtractSyntaxLocation_DeclBeforeDef()
+        {
+            var text =
+@"public partial class A {
+  partial void M();
+}
+public partial class A {
+  partial void M() {}
+}
+";
+            var comp = CreateStandardCompilation(text);
+            var global = comp.GlobalNamespace;
+            var a = global.GetTypeMembers("A", 0).Single();
+            var m = (MethodSymbol) a.GetMembers("M").Single();
+            Assert.True(m.IsPartialDefinition());
+            var returnSyntax = m.ExtractReturnTypeSyntax();
+
+            var tree = comp.SyntaxTrees.Single();
+            var model = comp.GetSemanticModel(tree);
+            var voidTokens = tree.GetRoot().DescendantTokens().Where(t => t.Kind() == SyntaxKind.VoidKeyword).ToList();
+            var node = tree.GetRoot().FindNode(voidTokens[0].Span);
+
+            var mLocations = tree.GetRoot().DescendantTokens().Where(t => t.ValueText == "M").ToList();
+            var otherSymbol = (MethodSymbol)model.GetDeclaredSymbolForNode(tree.GetRoot().FindNode(mLocations[1].Span));
+
+            Assert.Equal(node, returnSyntax);
+            Assert.Equal(node, otherSymbol.ExtractReturnTypeSyntax());
+        }
+
+        [Fact]
+        public void PartialExtractSyntaxLocation_DefBeforeDecl()
+        {
+            var text =
+@"public partial class A {
+  partial void M() {}
+}
+public partial class A {
+  partial void M();
+}
+";
+            var comp = CreateStandardCompilation(text);
+            var global = comp.GlobalNamespace;
+            var a = global.GetTypeMembers("A", 0).Single();
+            var m = (MethodSymbol) a.GetMembers("M").Single();
+            Assert.True(m.IsPartialDefinition());
+            var returnSyntax = m.ExtractReturnTypeSyntax();
+
+            var tree = comp.SyntaxTrees.Single();
+            var model = comp.GetSemanticModel(tree);
+            var token = tree.GetRoot().DescendantTokens().Where(t => t.Kind() == SyntaxKind.VoidKeyword).Skip(1).First();
+            var node = tree.GetRoot().FindNode(token.Span);
+
+            var mLocations = tree.GetRoot().DescendantTokens().Where(t => t.ValueText == "M").ToList();
+            var otherSymbol = (MethodSymbol)model.GetDeclaredSymbolForNode(tree.GetRoot().FindNode(mLocations[0].Span));
+
+            Assert.Equal(node, returnSyntax);
+            Assert.Equal(node, otherSymbol.ExtractReturnTypeSyntax());
+        }
+
+        [Fact]
+        public void PartialExtractSyntaxLocation_OnlyDef()
+        {
+            var text =
+@"public partial class A {
+  partial void M() {}
+}
+";
+            var comp = CreateStandardCompilation(text);
+            var global = comp.GlobalNamespace;
+            var a = global.GetTypeMembers("A", 0).Single();
+            var m = (MethodSymbol) a.GetMembers("M").Single();
+            Assert.True(m.IsPartialImplementation());
+            var returnSyntax = m.ExtractReturnTypeSyntax();
+
+            var tree = comp.SyntaxTrees.Single().GetRoot();
+            var token = tree.DescendantTokens().Where(t => t.Kind() == SyntaxKind.VoidKeyword).First();
+            var node = tree.FindNode(token.Span);
+
+            Assert.Equal(node, returnSyntax);
+        }
+
+        [Fact]
+        public void PartialExtractSyntaxLocation_OnlyDecl()
+        {
+            var text =
+@"public partial class A {
+  partial void M();
+}
+";
+            var comp = CreateStandardCompilation(text);
+            var global = comp.GlobalNamespace;
+            var a = global.GetTypeMembers("A", 0).Single();
+            var m = (MethodSymbol) a.GetMembers("M").Single();
+            Assert.True(m.IsPartialDefinition());
+            var returnSyntax = m.ExtractReturnTypeSyntax();
+
+            var tree = comp.SyntaxTrees.Single().GetRoot();
+            var token = tree.DescendantTokens().Where(t => t.Kind() == SyntaxKind.VoidKeyword).First();
+            var node = tree.FindNode(token.Span);
+
+            Assert.Equal(node, returnSyntax);
+        }
+
         [Fact]
         public void FullName()
         {
diff --git a/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs b/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
index 6e3c7bbbf80c9..917788c4d65bb 100644
--- a/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
@@ -105,6 +105,8 @@ internal CompilationVerifier CompileAndVerify(
             Action<ModuleSymbol> symbolValidator = null,
             SignatureDescription[] expectedSignatures = null,
             string expectedOutput = null,
+            int? expectedReturnCode = null,
+            string[] args = null,
             CompilationOptions options = null,
             ParseOptions parseOptions = null,
             EmitOptions emitOptions = null,
@@ -119,6 +121,8 @@ internal CompilationVerifier CompileAndVerify(
                 Translate2(symbolValidator),
                 expectedSignatures,
                 expectedOutput,
+                expectedReturnCode,
+                args,
                 options,
                 parseOptions,
                 emitOptions,
@@ -185,6 +189,8 @@ internal CompilationVerifier CompileAndVerify(
             Action<ModuleSymbol> symbolValidator = null,
             SignatureDescription[] expectedSignatures = null,
             string expectedOutput = null,
+            int? expectedReturnCode = null,
+            string[] args = null,
             EmitOptions emitOptions = null,
             bool verify = true)
         {
@@ -197,6 +203,8 @@ internal CompilationVerifier CompileAndVerify(
                 Translate2(symbolValidator),
                 expectedSignatures,
                 expectedOutput,
+                expectedReturnCode,
+                args,
                 emitOptions,
                 verify);
         }
diff --git a/src/Compilers/Test/Utilities/VisualBasic/BasicTestBase.vb b/src/Compilers/Test/Utilities/VisualBasic/BasicTestBase.vb
index b4d2d8109833c..1f2063c4ad3bc 100644
--- a/src/Compilers/Test/Utilities/VisualBasic/BasicTestBase.vb
+++ b/src/Compilers/Test/Utilities/VisualBasic/BasicTestBase.vb
@@ -37,6 +37,8 @@ Public MustInherit Class BasicTestBase
     Friend Shadows Function CompileAndVerify(
         source As XElement,
         expectedOutput As XCData,
+        Optional expectedReturnCode As Integer? = Nothing,
+        Optional args As String() = Nothing,
         Optional additionalRefs As MetadataReference() = Nothing,
         Optional dependencies As IEnumerable(Of ModuleData) = Nothing,
         Optional sourceSymbolValidator As Action(Of ModuleSymbol) = Nothing,
@@ -52,6 +54,8 @@ Public MustInherit Class BasicTestBase
         Return CompileAndVerify(
             source,
             XCDataToString(expectedOutput),
+            expectedReturnCode,
+            args,
             additionalRefs,
             dependencies,
             sourceSymbolValidator,
@@ -73,6 +77,8 @@ Public MustInherit Class BasicTestBase
         Optional symbolValidator As Action(Of ModuleSymbol) = Nothing,
         Optional expectedSignatures As SignatureDescription() = Nothing,
         Optional expectedOutput As String = Nothing,
+        Optional expectedReturnCode As Integer? = Nothing,
+        Optional args As String() = Nothing,
         Optional emitOptions As EmitOptions = Nothing,
         Optional verify As Boolean = True) As CompilationVerifier
 
@@ -85,6 +91,8 @@ Public MustInherit Class BasicTestBase
             Translate(symbolValidator),
             expectedSignatures,
             expectedOutput,
+            expectedReturnCode,
+            args,
             emitOptions,
             verify)
     End Function
@@ -92,6 +100,7 @@ Public MustInherit Class BasicTestBase
     Friend Shadows Function CompileAndVerify(
         compilation As Compilation,
         expectedOutput As XCData,
+        Optional args As String() = Nothing,
         Optional manifestResources As IEnumerable(Of ResourceDescription) = Nothing,
         Optional dependencies As IEnumerable(Of ModuleData) = Nothing,
         Optional sourceSymbolValidator As Action(Of ModuleSymbol) = Nothing,
@@ -110,6 +119,8 @@ Public MustInherit Class BasicTestBase
             symbolValidator,
             expectedSignatures,
             XCDataToString(expectedOutput),
+            Nothing,
+            args,
             emitOptions,
             verify)
     End Function
@@ -117,6 +128,8 @@ Public MustInherit Class BasicTestBase
     Friend Shadows Function CompileAndVerify(
         source As XElement,
         Optional expectedOutput As String = Nothing,
+        Optional expectedReturnCode As Integer? = Nothing,
+        Optional args As String() = Nothing,
         Optional additionalRefs As MetadataReference() = Nothing,
         Optional dependencies As IEnumerable(Of ModuleData) = Nothing,
         Optional sourceSymbolValidator As Action(Of ModuleSymbol) = Nothing,
@@ -136,6 +149,8 @@ Public MustInherit Class BasicTestBase
         Return Me.CompileAndVerify(source,
                                    allReferences,
                                    expectedOutput,
+                                   expectedReturnCode,
+                                   args,
                                    dependencies,
                                    sourceSymbolValidator,
                                    validator,
@@ -152,6 +167,8 @@ Public MustInherit Class BasicTestBase
         source As XElement,
         allReferences As IEnumerable(Of MetadataReference),
         Optional expectedOutput As String = Nothing,
+        Optional expectedReturnCode As Integer? = Nothing,
+        Optional args As String() = Nothing,
         Optional dependencies As IEnumerable(Of ModuleData) = Nothing,
         Optional sourceSymbolValidator As Action(Of ModuleSymbol) = Nothing,
         Optional validator As Action(Of PEAssembly) = Nothing,
@@ -180,6 +197,8 @@ Public MustInherit Class BasicTestBase
             Translate(symbolValidator),
             expectedSignatures,
             expectedOutput,
+            expectedReturnCode,
+            args,
             emitOptions,
             verify)
     End Function
@@ -188,6 +207,8 @@ Public MustInherit Class BasicTestBase
         source As String,
         allReferences As IEnumerable(Of MetadataReference),
         Optional expectedOutput As String = Nothing,
+        Optional expectedReturnCode As Integer? = Nothing,
+        Optional args As String() = Nothing,
         Optional dependencies As IEnumerable(Of ModuleData) = Nothing,
         Optional sourceSymbolValidator As Action(Of ModuleSymbol) = Nothing,
         Optional validator As Action(Of PEAssembly) = Nothing,
@@ -215,6 +236,8 @@ Public MustInherit Class BasicTestBase
             Translate(symbolValidator),
             expectedSignatures,
             expectedOutput,
+            expectedReturnCode,
+            args,
             emitOptions,
             verify)
     End Function
@@ -223,6 +246,8 @@ Public MustInherit Class BasicTestBase
         source As XElement,
         allReferences As IEnumerable(Of MetadataReference),
         Optional expectedOutput As String = Nothing,
+        Optional expectedReturnCode As Integer? = Nothing,
+        Optional args As String() = Nothing,
         Optional dependencies As IEnumerable(Of ModuleData) = Nothing,
         Optional sourceSymbolValidator As Action(Of ModuleSymbol) = Nothing,
         Optional validator As Action(Of PEAssembly) = Nothing,
@@ -236,6 +261,8 @@ Public MustInherit Class BasicTestBase
             source,
             allReferences,
             If(OSVersion.IsWin8, expectedOutput, Nothing),
+            If(OSVersion.IsWin8, expectedReturnCode, Nothing),
+            args,
             dependencies,
             sourceSymbolValidator,
             validator,
@@ -249,6 +276,8 @@ Public MustInherit Class BasicTestBase
     Friend Shadows Function CompileAndVerifyOnWin8Only(
         source As XElement,
         expectedOutput As XCData,
+        Optional expectedReturnCode As Integer? = Nothing,
+        Optional args As String() = Nothing,
         Optional allReferences() As MetadataReference = Nothing,
         Optional dependencies As IEnumerable(Of ModuleData) = Nothing,
         Optional sourceSymbolValidator As Action(Of ModuleSymbol) = Nothing,
@@ -263,6 +292,8 @@ Public MustInherit Class BasicTestBase
             source,
             allReferences,
             XCDataToString(expectedOutput),
+            expectedReturnCode,
+            args,
             dependencies,
             sourceSymbolValidator,
             validator,
diff --git a/src/Test/Utilities/CoreClr/CoreCLRRuntimeEnvironment.cs b/src/Test/Utilities/CoreClr/CoreCLRRuntimeEnvironment.cs
index 344c8311e0ee6..ff42a70857f42 100644
--- a/src/Test/Utilities/CoreClr/CoreCLRRuntimeEnvironment.cs
+++ b/src/Test/Utilities/CoreClr/CoreCLRRuntimeEnvironment.cs
@@ -72,23 +72,18 @@ public void Emit(
             }
         }
 
-        public (int ExitCode, string Output) Execute(string moduleName, int expectedOutputLength)
+        public int Execute(string moduleName, string[] args, string expectedOutput)
         {
             var emitData = GetEmitData();
             emitData.RuntimeData.ExecuteRequested = true;
-            return emitData.LoadContext.Execute(GetMainImage(), expectedOutputLength);
-        }
-
-        public int Execute(string moduleName, string expectedOutput)
-        {
-            var (exitCode, actualOutput) = Execute(moduleName, expectedOutput.Length);
+            var (ExitCode, Output) = emitData.LoadContext.Execute(GetMainImage(), args, expectedOutput?.Length);
 
-            if (expectedOutput.Trim() != actualOutput.Trim())
+            if (expectedOutput != null && expectedOutput.Trim() != Output.Trim())
             {
-                throw new ExecutionException(expectedOutput, actualOutput, moduleName);
+                throw new ExecutionException(expectedOutput, Output, moduleName);
             }
 
-            return exitCode;
+            return ExitCode;
         }
 
         private EmitData GetEmitData() => _emitData ?? throw new InvalidOperationException("Must call Emit before calling this method");
diff --git a/src/Test/Utilities/CoreClr/TestExecutionLoadContext.cs b/src/Test/Utilities/CoreClr/TestExecutionLoadContext.cs
index 152eae58ea14a..ccc7c6b986657 100644
--- a/src/Test/Utilities/CoreClr/TestExecutionLoadContext.cs
+++ b/src/Test/Utilities/CoreClr/TestExecutionLoadContext.cs
@@ -95,7 +95,7 @@ private Assembly LoadImageAsAssembly(ImmutableArray<byte> mainImage)
             }
         }
 
-        internal (int ExitCode, string Output) Execute(ImmutableArray<byte> mainImage, int expectedOutputLength)
+        internal (int ExitCode, string Output) Execute(ImmutableArray<byte> mainImage, string[] mainArgs, int? expectedOutputLength)
         {
             var mainAssembly = LoadImageAsAssembly(mainImage);
             var entryPoint = mainAssembly.EntryPoint;
@@ -113,7 +113,7 @@ private Assembly LoadImageAsAssembly(ImmutableArray<byte> mainImage)
                 }
                 else if (count == 1)
                 {
-                    args = new[] { Array.Empty<string>() };
+                    args = new[] { mainArgs ?? Array.Empty<string>() };
                 }
                 else
                 {
@@ -121,7 +121,7 @@ private Assembly LoadImageAsAssembly(ImmutableArray<byte> mainImage)
                 }
 
                 exitCode = entryPoint.Invoke(null, args) is int exit ? exit : 0;
-            }, expectedOutputLength, out var stdOut, out var stdErr);
+            }, expectedOutputLength ?? 0, out var stdOut, out var stdErr);
 
             var output = stdOut + stdErr;
             return (exitCode, output);
diff --git a/src/Test/Utilities/Desktop/CodeRuntime/DesktopRuntimeEnvironment.cs b/src/Test/Utilities/Desktop/CodeRuntime/DesktopRuntimeEnvironment.cs
index 0ce20aa65f134..d53f86217b336 100644
--- a/src/Test/Utilities/Desktop/CodeRuntime/DesktopRuntimeEnvironment.cs
+++ b/src/Test/Utilities/Desktop/CodeRuntime/DesktopRuntimeEnvironment.cs
@@ -236,13 +236,22 @@ public void Emit(
             }
         }
 
-        public int Execute(string moduleName, int expectedOutputLength, out string processOutput)
+        public int Execute(string moduleName, string[] args, string expectedOutput)
         {
             try
             {
                 var emitData = GetEmitData();
                 emitData.RuntimeData.ExecuteRequested = true;
-                return emitData.Manager.Execute(moduleName, expectedOutputLength, out processOutput);
+                var resultCode = emitData.Manager.Execute(moduleName, args, expectedOutput?.Length, out var output);
+
+                if (expectedOutput != null && expectedOutput.Trim() != output.Trim())
+                {
+                    string dumpDir;
+                    GetEmitData().Manager.DumpAssemblyData(out dumpDir);
+                    throw new ExecutionException(expectedOutput, output, dumpDir);
+                }
+
+                return resultCode;
             }
             catch (TargetInvocationException tie)
             {
@@ -257,21 +266,6 @@ public int Execute(string moduleName, int expectedOutputLength, out string proce
             }
         }
 
-        public int Execute(string moduleName, string expectedOutput)
-        {
-            string actualOutput;
-            int exitCode = Execute(moduleName, expectedOutput.Length, out actualOutput);
-
-            if (expectedOutput.Trim() != actualOutput.Trim())
-            {
-                string dumpDir;
-                GetEmitData().Manager.DumpAssemblyData(out dumpDir);
-                throw new ExecutionException(expectedOutput, actualOutput, dumpDir);
-            }
-
-            return exitCode;
-        }
-
         private EmitData GetEmitData()
         {
             if (_emitData == null)
diff --git a/src/Test/Utilities/Desktop/CodeRuntime/RuntimeAssemblyManager.cs b/src/Test/Utilities/Desktop/CodeRuntime/RuntimeAssemblyManager.cs
index 6da88bfff43f6..d293baeee4b72 100644
--- a/src/Test/Utilities/Desktop/CodeRuntime/RuntimeAssemblyManager.cs
+++ b/src/Test/Utilities/Desktop/CodeRuntime/RuntimeAssemblyManager.cs
@@ -367,7 +367,7 @@ private SortedSet<string> GetFullyQualifiedTypeNames(string assemblyName)
             return typeNames;
         }
 
-        public int Execute(string moduleName, int expectedOutputLength, out string output)
+        public int Execute(string moduleName, string[] mainArgs, int? expectedOutputLength, out string output)
         {
             ImmutableArray<byte> bytes = GetModuleBytesByName(moduleName);
             Assembly assembly = DesktopRuntimeUtil.LoadAsAssembly(moduleName, bytes);
@@ -386,7 +386,7 @@ public int Execute(string moduleName, int expectedOutputLength, out string outpu
                 }
                 else if (count == 1)
                 {
-                    args = new object[] { new string[0] };
+                    args = new object[] { mainArgs ?? new string[0] };
                 }
                 else
                 {
@@ -394,7 +394,7 @@ public int Execute(string moduleName, int expectedOutputLength, out string outpu
                 }
 
                 result = entryPoint.Invoke(null, args);
-            }, expectedOutputLength, out stdOut, out stdErr);
+            }, expectedOutputLength ?? 0, out stdOut, out stdErr);
 
             output = stdOut + stdErr;
             return result is int ? (int)result : 0;
diff --git a/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs b/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs
index 67a41c836262f..a6d74a7b1b800 100644
--- a/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs
+++ b/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs
@@ -88,7 +88,7 @@ internal ImmutableArray<ModuleMetadata> GetAllModuleMetadata()
                 return modules;
             }
 
-            public void Emit(string expectedOutput, IEnumerable<ResourceDescription> manifestResources, EmitOptions emitOptions, bool peVerify, SignatureDescription[] expectedSignatures)
+            public void Emit(string expectedOutput, int? expectedReturnCode, string[] args, IEnumerable<ResourceDescription> manifestResources, EmitOptions emitOptions, bool peVerify, SignatureDescription[] expectedSignatures)
             {
                 using (var testEnvironment = RuntimeEnvironmentFactory.Create(_dependencies))
                 {
@@ -105,9 +105,14 @@ public void Emit(string expectedOutput, IEnumerable<ResourceDescription> manifes
                         MetadataSignatureUnitTestHelper.VerifyMemberSignatures(testEnvironment, expectedSignatures);
                     }
 
-                    if (expectedOutput != null)
+                    if (expectedOutput != null || expectedReturnCode != null)
                     {
-                        testEnvironment.Execute(mainModuleName, expectedOutput);
+                        var returnCode = testEnvironment.Execute(mainModuleName, args, expectedOutput);
+
+                        if (expectedReturnCode is int exCode)
+                        {
+                            Assert.Equal(exCode, returnCode);
+                        }
                     }
                 }
             }
diff --git a/src/Test/Utilities/Portable/CommonTestBase.cs b/src/Test/Utilities/Portable/CommonTestBase.cs
index 1b944cf6208fd..d1adacc3af754 100644
--- a/src/Test/Utilities/Portable/CommonTestBase.cs
+++ b/src/Test/Utilities/Portable/CommonTestBase.cs
@@ -73,6 +73,8 @@ internal CompilationVerifier CompileAndVerify(
             Action<IModuleSymbol> symbolValidator = null,
             SignatureDescription[] expectedSignatures = null,
             string expectedOutput = null,
+            int? expectedReturnCode = null,
+            string[] args = null,
             CompilationOptions options = null,
             ParseOptions parseOptions = null,
             EmitOptions emitOptions = null,
@@ -94,6 +96,8 @@ internal CompilationVerifier CompileAndVerify(
                 symbolValidator,
                 expectedSignatures,
                 expectedOutput,
+                expectedReturnCode,
+                args,
                 emitOptions,
                 verify);
         }
@@ -107,6 +111,8 @@ internal CompilationVerifier CompileAndVerify(
             Action<IModuleSymbol> symbolValidator = null,
             SignatureDescription[] expectedSignatures = null,
             string expectedOutput = null,
+            int? expectedReturnCode = null,
+            string[] args = null,
             EmitOptions emitOptions = null,
             bool verify = true)
         {
@@ -136,6 +142,8 @@ internal CompilationVerifier CompileAndVerify(
                                 manifestResources,
                                 expectedSignatures,
                                 expectedOutput,
+                                expectedReturnCode,
+                                args ?? Array.Empty<string>(),
                                 assemblyValidator,
                                 symbolValidator,
                                 emitOptions,
@@ -199,6 +207,8 @@ internal CompilationVerifier Emit(
             IEnumerable<ResourceDescription> manifestResources,
             SignatureDescription[] expectedSignatures,
             string expectedOutput,
+            int? expectedReturnCode,
+            string[] args,
             Action<PEAssembly> assemblyValidator,
             Action<IModuleSymbol> symbolValidator,
             EmitOptions emitOptions,
@@ -208,7 +218,7 @@ internal CompilationVerifier Emit(
 
             verifier = new CompilationVerifier(this, compilation, dependencies);
 
-            verifier.Emit(expectedOutput, manifestResources, emitOptions, verify, expectedSignatures);
+            verifier.Emit(expectedOutput, expectedReturnCode, args, manifestResources, emitOptions, verify, expectedSignatures);
 
             // We're dual-purposing emitters here.  In this context, it
             // tells the validator the version of Emit that is calling it. 
diff --git a/src/Test/Utilities/Portable/Compilation/IRuntimeEnvironment.cs b/src/Test/Utilities/Portable/Compilation/IRuntimeEnvironment.cs
index 11b640f8dcfa6..30d39f1b4cb0c 100644
--- a/src/Test/Utilities/Portable/Compilation/IRuntimeEnvironment.cs
+++ b/src/Test/Utilities/Portable/Compilation/IRuntimeEnvironment.cs
@@ -367,7 +367,7 @@ public interface IRuntimeEnvironmentFactory
     public interface IRuntimeEnvironment : IDisposable
     {
         void Emit(Compilation mainCompilation, IEnumerable<ResourceDescription> manifestResources, EmitOptions emitOptions, bool usePdbForDebugging = false);
-        int Execute(string moduleName, string expectedOutput);
+        int Execute(string moduleName, string[] args, string expectedOutput);
         ImmutableArray<byte> GetMainImage();
         ImmutableArray<byte> GetMainPdb();
         ImmutableArray<Diagnostic> GetDiagnostics();

From 01b6ea3321f99724454c7cfb7044fb9cb8d57cc8 Mon Sep 17 00:00:00 2001
From: Ty Overby <ty@pre-alpha.com>
Date: Fri, 28 Apr 2017 13:24:42 -0700
Subject: [PATCH 024/284] fix resx file

---
 src/Compilers/CSharp/Portable/CSharpResources.resx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index 2967dd9950625..4812dab66b164 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -5061,6 +5061,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   </data>
   <data name="IDS_FeatureAsyncMain" xml:space="preserve">
     <value>async main</value>
+  </data>
   <data name="ERR_TupleInferredNamesNotAvailable" xml:space="preserve">
     <value>Tuple element name '{0}' is inferred. Please use language version {1} or greater to access an element by its inferred name.</value>
   </data>

From 32a9e283e257ca9a42f95ca0010153fb6f924486 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Tue, 2 May 2017 15:41:59 -0700
Subject: [PATCH 025/284] Add .mvid section to PE and remove dependency on
 MetadataReader (#19133)

---
 docs/compilers/CSharp/CommandLine.md          |   2 +
 docs/compilers/Visual Basic/CommandLine.md    |   2 +
 docs/features/refout.md                       |   9 +-
 .../Test/Emit/CSharpCompilerEmitTest.csproj   |   3 +
 .../Test/Emit/Emit/CompilationEmitTests.cs    | 124 ++++++++++-
 .../Test/Emit/Emit/DeterministicTests.cs      |  25 ++-
 .../Core/MSBuildTask/CopyRefAssembly.cs       |   6 +-
 .../Core/MSBuildTask/MSBuildTask.csproj       |   1 +
 src/Compilers/Core/MSBuildTask/MvidReader.cs  | 210 ++++++++++++++++++
 src/Compilers/Core/MSBuildTask/project.json   |   1 -
 .../Core/Portable/CodeAnalysis.csproj         |   1 +
 .../Portable/PEWriter/ExtendedPEBuilder.cs    | 100 +++++++++
 .../Core/Portable/PEWriter/PeWriter.cs        |  21 +-
 13 files changed, 485 insertions(+), 20 deletions(-)
 create mode 100755 src/Compilers/Core/MSBuildTask/MvidReader.cs
 create mode 100755 src/Compilers/Core/Portable/PEWriter/ExtendedPEBuilder.cs

diff --git a/docs/compilers/CSharp/CommandLine.md b/docs/compilers/CSharp/CommandLine.md
index 8244ce7bfc71e..5f78b84f8a6ae 100644
--- a/docs/compilers/CSharp/CommandLine.md
+++ b/docs/compilers/CSharp/CommandLine.md
@@ -4,6 +4,7 @@
 | ---- | ---- |
 | **OUTPUT FILES** |
 | `/out:`*file* | Specify output file name (default: base name of file with main class or first file)
+| `/refout:`*file* | Specify the reference assembly's output file name
 | `/target:exe` |  Build a console executable (default) (Short form: `/t:exe`)
 | `/target:winexe` | Build a Windows executable (Short form: `/t:winexe` )
 | `/target:library` | Build a library (Short form: `/t:library`)
@@ -32,6 +33,7 @@
 | `/debug`:{`full`&#124;`pdbonly`&#124;`portable`} | Specify debugging type (`full` is default, and  enables attaching a debugger to a running program. `portable` is a cross-platform format)
 | `/optimize`{`+`&#124;`-`} | Enable optimizations (Short form: `/o`)
 | `/deterministic` | Produce a deterministic assembly (including module version GUID and timestamp)
+| `/refonly | Produce a reference assembly, instead of a full assembly, as the primary output 
 | **ERRORS AND WARNINGS**
 | `/warnaserror`{`+`&#124;`-`} | Report all warnings as errors
 | `/warnaserror`{`+`&#124;`-`}`:`*warn list* | Report specific warnings as errors
diff --git a/docs/compilers/Visual Basic/CommandLine.md b/docs/compilers/Visual Basic/CommandLine.md
index 0a7afcefd67da..e7c44304aa4fa 100644
--- a/docs/compilers/Visual Basic/CommandLine.md	
+++ b/docs/compilers/Visual Basic/CommandLine.md	
@@ -4,6 +4,7 @@
 | ---- | ---- |
 | **OUTPUT FILE**
 | `/out:`*file* | Specifies the output file name.
+| `/refout:`*file* | Specify the reference assembly's output file name
 | `/target:exe` | Create a console application (default). (Short form: `/t`)
 | `/target:winexe` | Create a Windows application.
 | `/target:library` | Create a library assembly.
@@ -34,6 +35,7 @@
 | `/debug:portable` | Emit debugging information in the portable format.
 | `/debug:pdbonly` | Emit PDB file only.
 | `/deterministic` | Produce a deterministic assembly (including module version GUID and timestamp)
+| `/refonly | Produce a reference assembly, instead of a full assembly, as the primary output 
 | **ERRORS AND WARNINGS**
 | `/nowarn` | Disable all warnings.
 | `/nowarn:`*number_list* | Disable a list of individual warnings.
diff --git a/docs/features/refout.md b/docs/features/refout.md
index 9e533c52c72f7..9ab450afc9ffc 100644
--- a/docs/features/refout.md
+++ b/docs/features/refout.md
@@ -32,11 +32,12 @@ Two mutually exclusive command-line parameters will be added to `csc.exe` and `v
 - `/refout`
 - `/refonly`
 
-The `/refout` parameter specifies a file path where the ref assembly should be output. This translates to `metadataPeStream` in the `Emit` API (see details below).
+The `/refout` parameter specifies a file path where the ref assembly should be output. This translates to `metadataPeStream` in the `Emit` API (see details below). The filename for the ref assembly should generally match that of the primary assembly, but it can be in a different folder.
 
 The `/refonly` parameter is a flag that indicates that a ref assembly should be output instead of an implementation assembly. 
 The `/refonly` parameter is not allowed together with the `/refout` parameter, as it doesn't make sense to have both the primary and secondary outputs be ref assemblies. Also, the `/refonly` parameter silently disables outputting PDBs, as ref assemblies cannot be executed. 
 The `/refonly` parameter translates to `EmitMetadataOnly` being `true`, and `IncludePrivateMembers` being `false` in the `Emit` API (see details below).
+Neither `/refonly` nor `/refout` are permitted with `/target:module` or `/addmodule` options.
 
 When the compiler produces documentation, the contents produced will match the APIs that go into the primary output. In other words, the documentation will be filtered down when using the `/refonly` parameter.
 
@@ -47,13 +48,14 @@ The `CoreCompile` target will support a new output, called `IntermediateRefAssem
 The `Csc` task will support a new output, called `OutputRefAssembly`, which parallels the existing `OutputAssembly`.
 Both of those basically map to the `/refout` command-line parameter.
 
-An additional task, called `CopyRefAssembly`, will be provided along with the existing `Csc` task. It takes a `SourcePath` and a `DestinationPath` and generally copies the file from the source over to the destination. But if it can determine that the contents of those two files match, then the destination file is left untouched.
+An additional task, called `CopyRefAssembly`, will be provided along with the existing `Csc` task. It takes a `SourcePath` and a `DestinationPath` and generally copies the file from the source over to the destination. But if it can determine that the contents of those two files match (by comparing their MVIDs, see details below), then the destination file is left untouched.
 
 ### CodeAnalysis APIs
 It is already possible to produce metadata-only assemblies by using `EmitOptions.EmitMetadataOnly`, which is used in IDE scenarios with cross-language dependencies.
 The compiler will be updated to honour the `EmitOptions.IncludePrivateMembers` flag as well. When combined with `EmitMetadataOnly` or a `metadataPeStream` in `Emit`, a ref assembly will be produced.
-The diagnostic check for emitting methods lacking a body (`void M();`) will be moved from declaration diagnostics to regular diagnostics, so that code will successfully emit with `EmitMetadataOnly`.
+The diagnostic check for emitting methods lacking a body (`void M();`) will be filtered from declaration diagnostics, so that code will successfully emit with `EmitMetadataOnly`.
 Later on, the `EmitOptions.TolerateErrors` flag will allow emitting error types as well.
+`Emit` is also modified to produce a new PE section called ".mvid" containing a copy of the MVID, when producing ref assemblies. This makes it easy for `CopyRefAssembly` to extract and compare MVIDs from ref assemblies.
 
 Going back to the 4 driving scenarios:
 1. For a regular compilation, `EmitMetadataOnly` is left to `false` and no `metadataPeStream` is passed into `Emit`.
@@ -70,7 +72,6 @@ As mentioned above, there may be further refinements after C# 7.1:
 - should explicit method implementations be included in ref assemblies?
 - Non-public attributes on public APIs (emit attribute based on accessibility rule)
 - ref assemblies and NoPia
-- `/refout` and `/addmodule`, should we disallow this combination?
 
 ## Related issues
 - Produce ref assemblies from command-line and msbuild (https://github.com/dotnet/roslyn/issues/2184)
diff --git a/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj b/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj
index 2b69608a19d3d..89673c5a909f2 100644
--- a/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj
+++ b/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj
@@ -55,6 +55,9 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'" />
   <ItemGroup>
+    <Compile Include="..\..\..\Core\MSBuildTask\MvidReader.cs">
+      <Link>Emit\MvidReader.cs</Link>
+    </Compile>
     <Compile Include="Attributes\AttributeTests.cs" />
     <Compile Include="Attributes\AttributeTests_Assembly.cs" />
     <Compile Include="Attributes\AttributeTests_CallerInfoAttributes.cs" />
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
index abc39c4f664aa..77ed494cf7dc7 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.IO;
 using System.Linq;
@@ -49,7 +50,6 @@ public void Main()
                 Diagnostic(ErrorCode.ERR_AssgLvalueExpected, "x"));
         }
 
-
         [Fact]
         public void CompilationEmitWithQuotedMainType()
         {
@@ -262,9 +262,11 @@ internal static void Main()
 
                 VerifyEntryPoint(output, expectZero: false);
                 VerifyMethods(output, new[] { "void C.Main()", "C..ctor()" });
+                VerifyMvid(output, hasMvidSection: false);
 
                 VerifyEntryPoint(metadataOutput, expectZero: true);
                 VerifyMethods(metadataOutput, new[] { "C..ctor()" });
+                VerifyMvid(metadataOutput, hasMvidSection: true);
             }
 
             void VerifyEntryPoint(MemoryStream stream, bool expectZero)
@@ -275,6 +277,110 @@ void VerifyEntryPoint(MemoryStream stream, bool expectZero)
             }
         }
 
+        private class TestResourceSectionBuilder : ResourceSectionBuilder
+        {
+            public TestResourceSectionBuilder()
+            {
+            }
+
+            protected override void Serialize(BlobBuilder builder, SectionLocation location)
+            {
+                builder.WriteInt32(0x12345678);
+                builder.WriteInt32(location.PointerToRawData);
+                builder.WriteInt32(location.RelativeVirtualAddress);
+            }
+        }
+
+        private class TestPEBuilder : ManagedPEBuilder
+        {
+            public static readonly Guid s_mvid = Guid.Parse("a78fa2c3-854e-42bf-8b8d-75a450a6dc18");
+
+            public TestPEBuilder(PEHeaderBuilder header,
+                MetadataRootBuilder metadataRootBuilder,
+                BlobBuilder ilStream,
+                ResourceSectionBuilder nativeResources)
+                : base(header, metadataRootBuilder, ilStream, nativeResources: nativeResources)
+            {
+            }
+
+            protected override ImmutableArray<Section> CreateSections()
+            {
+                return base.CreateSections().Add(
+                     new Section(".mvid", SectionCharacteristics.MemRead |
+                        SectionCharacteristics.ContainsInitializedData |
+                        SectionCharacteristics.MemDiscardable));
+            }
+
+            protected override BlobBuilder SerializeSection(string name, SectionLocation location)
+            {
+                if (name.Equals(".mvid", StringComparison.Ordinal))
+                {
+                    var sectionBuilder = new BlobBuilder();
+                    sectionBuilder.WriteGuid(s_mvid);
+                    return sectionBuilder;
+                }
+
+                return base.SerializeSection(name, location);
+            }
+        }
+
+        [Fact]
+        public void MvidSectionNotFirst()
+        {
+            var ilBuilder = new BlobBuilder();
+            var metadataBuilder = new MetadataBuilder();
+
+            var peBuilder = new TestPEBuilder(
+                PEHeaderBuilder.CreateLibraryHeader(),
+                new MetadataRootBuilder(metadataBuilder),
+                ilBuilder,
+                nativeResources: new TestResourceSectionBuilder());
+
+            var peBlob = new BlobBuilder();
+            peBuilder.Serialize(peBlob);
+
+            var peStream = new MemoryStream();
+            peBlob.WriteContentTo(peStream);
+
+            peStream.Position = 0;
+            using (var peReader = new PEReader(peStream))
+            {
+                AssertEx.Equal(new[] { ".text", ".rsrc", ".reloc", ".mvid" },
+                    peReader.PEHeaders.SectionHeaders.Select(h => h.Name));
+
+                peStream.Position = 0;
+                var mvid = BuildTasks.MvidReader.ReadAssemblyMvidOrEmpty(peStream);
+                Assert.Equal(TestPEBuilder.s_mvid, mvid);
+            }
+        }
+
+        /// <summary>
+        /// Extract the MVID using two different methods (PEReader and MvidReader) and compare them. 
+        /// We only expect an .mvid section in ref assemblies.
+        /// </summary>
+        private void VerifyMvid(MemoryStream stream, bool hasMvidSection)
+        {
+            stream.Position = 0;
+            using (var reader = new PEReader(stream))
+            {
+                var metadataReader = reader.GetMetadataReader();
+                Guid mvidFromModuleDefinition = metadataReader.GetGuid(metadataReader.GetModuleDefinition().Mvid);
+
+                stream.Position = 0;
+                var mvidFromMvidReader = BuildTasks.MvidReader.ReadAssemblyMvidOrEmpty(stream);
+
+                Assert.NotEqual(Guid.Empty, mvidFromModuleDefinition);
+                if (hasMvidSection)
+                {
+                    Assert.Equal(mvidFromModuleDefinition, mvidFromMvidReader);
+                }
+                else
+                {
+                    Assert.Equal(Guid.Empty, mvidFromMvidReader);
+                }
+            }
+        }
+
         [Fact]
         public void EmitRefAssembly_PrivatePropertySetter()
         {
@@ -296,6 +402,8 @@ public class C
                 VerifyMethods(output, new[] { "System.Int32 C.<PrivateSetter>k__BackingField", "System.Int32 C.PrivateSetter.get", "void C.PrivateSetter.set",
                     "C..ctor()", "System.Int32 C.PrivateSetter { get; private set; }" });
                 VerifyMethods(metadataOutput, new[] { "System.Int32 C.PrivateSetter.get", "C..ctor()", "System.Int32 C.PrivateSetter { get; }" });
+                VerifyMvid(output, hasMvidSection: false);
+                VerifyMvid(metadataOutput, hasMvidSection: true);
             }
         }
 
@@ -559,6 +667,20 @@ private void CompareAssemblies(string sourceTemplate, string change1, string cha
             {
                 AssertEx.NotEqual(image1, image2, message: $"Expecting difference for includePrivateMembers={includePrivateMembers} case, but they matched.");
             }
+
+            var mvid1 = BuildTasks.MvidReader.ReadAssemblyMvidOrEmpty(new MemoryStream(image1.DangerousGetUnderlyingArray()));
+            var mvid2 = BuildTasks.MvidReader.ReadAssemblyMvidOrEmpty(new MemoryStream(image2.DangerousGetUnderlyingArray()));
+
+            if (!includePrivateMembers)
+            {
+                Assert.NotEqual(Guid.Empty, mvid1);
+                Assert.Equal(expectMatch, mvid1 == mvid2);
+            }
+            else
+            {
+                Assert.Equal(Guid.Empty, mvid1);
+                Assert.Equal(Guid.Empty, mvid2);
+            }
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/DeterministicTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/DeterministicTests.cs
index 2d98c539a82f6..a3a6be5cbb7b4 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/DeterministicTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/DeterministicTests.cs
@@ -18,14 +18,19 @@ namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Emit
     public class DeterministicTests : EmitMetadataTestBase
     {
         private Guid CompiledGuid(string source, string assemblyName, bool debug)
+        {
+            return CompiledGuid(source, assemblyName, options: debug ? TestOptions.DebugExe : TestOptions.ReleaseExe);
+        }
+
+        private Guid CompiledGuid(string source, string assemblyName, CSharpCompilationOptions options, EmitOptions emitOptions = null)
         {
             var compilation = CreateCompilation(source,
                 assemblyName: assemblyName,
                 references: new[] { MscorlibRef },
-                options: (debug ? TestOptions.DebugExe : TestOptions.ReleaseExe).WithDeterministic(true));
+                options: options.WithDeterministic(true));
 
             Guid result = default(Guid);
-            base.CompileAndVerify(compilation, validator: a =>
+            base.CompileAndVerify(compilation, emitOptions: emitOptions, validator: a =>
             {
                 var module = a.Modules[0];
                 result = module.GetModuleVersionIdOrThrow();
@@ -104,6 +109,22 @@ public static void Main(string[] args) {}
             Assert.NotEqual(mvid3, mvid7);
         }
 
+        [Fact]
+        public void RefAssembly()
+        {
+            var source =
+@"class Program
+{
+    public static void Main(string[] args) {}
+    CHANGE
+}";
+            var emitRefAssembly = EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false);
+
+            var mvid1 = CompiledGuid(source.Replace("CHANGE", ""), "X1", TestOptions.DebugDll, emitRefAssembly);
+            var mvid2 = CompiledGuid(source.Replace("CHANGE", "private void M() { }"), "X1", TestOptions.DebugDll, emitRefAssembly);
+            Assert.Equal(mvid1, mvid2);
+        }
+
         const string CompareAllBytesEmitted_Source = @"
 using System;
 using System.Linq;
diff --git a/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs b/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs
index 1c2f34c70646a..5b12dc838c517 100644
--- a/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs
+++ b/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs
@@ -2,8 +2,6 @@
 
 using System;
 using System.IO;
-using System.Reflection.Metadata;
-using System.Reflection.PortableExecutable;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
 
@@ -85,10 +83,8 @@ private bool Copy()
         private Guid ExtractMvid(string path)
         {
             using (FileStream source = File.OpenRead(path))
-            using (var reader = new PEReader(source))
             {
-                var metadataReader = reader.GetMetadataReader();
-                return metadataReader.GetGuid(metadataReader.GetModuleDefinition().Mvid);
+                return MvidReader.ReadAssemblyMvidOrEmpty(source);
             }
         }
     }
diff --git a/src/Compilers/Core/MSBuildTask/MSBuildTask.csproj b/src/Compilers/Core/MSBuildTask/MSBuildTask.csproj
index cbced79b1b505..9c161e6aa519b 100644
--- a/src/Compilers/Core/MSBuildTask/MSBuildTask.csproj
+++ b/src/Compilers/Core/MSBuildTask/MSBuildTask.csproj
@@ -55,6 +55,7 @@
     </Compile>
     <Compile Include="AssemblyResolution.cs" />
     <Compile Include="CanonicalError.cs" />
+    <Compile Include="MvidReader.cs" />
     <Compile Include="CopyRefAssembly.cs" />
     <Compile Include="ValidateBootstrap.cs" />
     <Compile Include="CommandLineBuilderExtension.cs" />
diff --git a/src/Compilers/Core/MSBuildTask/MvidReader.cs b/src/Compilers/Core/MSBuildTask/MvidReader.cs
new file mode 100755
index 0000000000000..745fdf24fbb11
--- /dev/null
+++ b/src/Compilers/Core/MSBuildTask/MvidReader.cs
@@ -0,0 +1,210 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+
+namespace Microsoft.CodeAnalysis.BuildTasks
+{
+    public static class MvidReader
+    {
+        private static readonly Guid s_empty = Guid.Empty;
+
+        public static Guid ReadAssemblyMvidOrEmpty(Stream stream)
+        {
+            return ReadAssemblyMvidOrEmpty(new BinaryReader(stream));
+        }
+
+        private static Guid ReadAssemblyMvidOrEmpty(BinaryReader reader)
+        {
+            // DOS Header: Magic number (2)
+            if (!ReadUInt16(reader, out ushort magicNumber) || magicNumber != 0x5a4d) // "MZ"
+            {
+                return s_empty;
+            }
+
+            // DOS Header: Address of PE Signature (at 0x3C)
+            if (!MoveTo(0x3C, reader))
+            {
+                return s_empty;
+            }
+            if (!ReadUInt32(reader, out uint pointerToPeSignature))
+            {
+                return s_empty;
+            }
+
+            // jump over the MS DOS Stub to the PE Signature
+            if (!MoveTo(pointerToPeSignature, reader))
+            {
+                return s_empty;
+            }
+
+            // PE Signature ('P' 'E' null null)
+            if (!ReadUInt32(reader, out uint peSig) || peSig != 0x00004550)
+            {
+                return s_empty;
+            }
+
+            // COFF Header: Machine (2)
+            if (!Skip(2, reader))
+            {
+                return s_empty;
+            }
+
+            // COFF Header: NumberOfSections (2)
+            if (!ReadUInt16(reader, out ushort sections))
+            {
+                return s_empty;
+            }
+
+            // COFF Header: TimeDateStamp (4), PointerToSymbolTable (4), NumberOfSymbols (4)
+            if (!Skip(12, reader))
+            {
+                return s_empty;
+            }
+
+            // COFF Header: OptionalHeaderSize (2)
+            if (!ReadUInt16(reader, out ushort optionalHeaderSize))
+            {
+                return s_empty;
+            }
+
+            // COFF Header: Characteristics (2)
+            if (!Skip(2, reader))
+            {
+                return s_empty;
+            }
+
+            // Optional header
+            if (!Skip(optionalHeaderSize, reader))
+            {
+                return s_empty;
+            }
+
+            // Section headers
+            return FindMvidInSections(sections, reader);
+        }
+
+        private static Guid FindMvidInSections(ushort count, BinaryReader reader)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                // Section: Name (8)
+                if (!ReadBytes(reader, 8, out byte[] name))
+                {
+                    return s_empty;
+                }
+
+                if (name.Length == 8 && name[0] == '.' &&
+                    name[1] == 'm' && name[2] == 'v' && name[3] == 'i' && name[4] == 'd' && name[5] == '\0')
+                {
+                    // Section: VirtualSize (4)
+                    if (!ReadUInt32(reader, out uint virtualSize) || virtualSize != 16)
+                    {
+                        // The .mvid section only stores a Guid
+                        return s_empty;
+                    }
+
+                    // Section: VirtualAddress (4), SizeOfRawData (4)
+                    if (!Skip(8, reader))
+                    {
+                        return s_empty;
+                    }
+
+                    // Section: PointerToRawData (4)
+                    if (!ReadUInt32(reader, out uint pointerToRawData))
+                    {
+                        return s_empty;
+                    }
+
+                    return ReadMvidSection(reader, pointerToRawData);
+                }
+                else
+                {
+                    // Section: VirtualSize (4), VirtualAddress (4), SizeOfRawData (4),
+                    // PointerToRawData (4), PointerToRelocations (4), PointerToLineNumbers (4),
+                    // NumberOfRelocations (2), NumberOfLineNumbers (2), Characteristics (4)
+                    if (!Skip(4 + 4 + 4 + 4 + 4 + 4 + 2 + 2 + 4, reader))
+                    {
+                        return s_empty;
+                    }
+                }
+            }
+
+            return s_empty;
+        }
+
+        private static Guid ReadMvidSection(BinaryReader reader, uint pointerToMvidSection)
+        {
+            if (!MoveTo(pointerToMvidSection, reader))
+            {
+                return s_empty;
+            }
+
+            if (!ReadBytes(reader, 16, out byte[] guidBytes))
+            {
+                return s_empty;
+            }
+
+            return new Guid(guidBytes);
+        }
+
+        private static bool ReadUInt16(BinaryReader reader, out ushort output)
+        {
+            if (reader.BaseStream.Position + 2 >= reader.BaseStream.Length)
+            {
+                output = 0;
+                return false;
+            }
+
+            output = reader.ReadUInt16();
+            return true;
+        }
+
+        private static bool ReadUInt32(BinaryReader reader, out uint output)
+        {
+            if (reader.BaseStream.Position + 4 >= reader.BaseStream.Length)
+            {
+                output = 0;
+                return false;
+            }
+
+            output = reader.ReadUInt32();
+            return true;
+        }
+
+        private static bool ReadBytes(BinaryReader reader, int count, out byte[] output)
+        {
+            if (reader.BaseStream.Position + count >= reader.BaseStream.Length)
+            {
+                output = null;
+                return false;
+            }
+
+            output = reader.ReadBytes(count);
+            return true;
+        }
+
+        private static bool Skip(int bytes, BinaryReader reader)
+        {
+            if (reader.BaseStream.Position + bytes >= reader.BaseStream.Length)
+            {
+                return false;
+            }
+
+            reader.BaseStream.Seek(bytes, SeekOrigin.Current);
+            return true;
+        }
+
+        private static bool MoveTo(uint position, BinaryReader reader)
+        {
+            if (position >= reader.BaseStream.Length)
+            {
+                return false;
+            }
+
+            reader.BaseStream.Seek(position, SeekOrigin.Begin);
+            return true;
+        }
+    }
+}
diff --git a/src/Compilers/Core/MSBuildTask/project.json b/src/Compilers/Core/MSBuildTask/project.json
index c9efa1ac00175..ac0c51a5b3082 100644
--- a/src/Compilers/Core/MSBuildTask/project.json
+++ b/src/Compilers/Core/MSBuildTask/project.json
@@ -15,7 +15,6 @@
     "System.IO.Pipes": "4.3.0",
     "System.Linq": "4.3.0",
     "System.Reflection": "4.3.0",
-    "System.Reflection.Metadata": "1.4.2",
     "System.Security.AccessControl": "4.3.0",
     "System.Security.Cryptography.Algorithms": "4.3.0",
     "System.Security.Principal.Windows": "4.3.0",
diff --git a/src/Compilers/Core/Portable/CodeAnalysis.csproj b/src/Compilers/Core/Portable/CodeAnalysis.csproj
index 1581cbd140c2f..d871379ace22a 100644
--- a/src/Compilers/Core/Portable/CodeAnalysis.csproj
+++ b/src/Compilers/Core/Portable/CodeAnalysis.csproj
@@ -140,6 +140,7 @@
     <Compile Include="Emit\AsyncMoveNextBodyDebugInfo.cs" />
     <Compile Include="Emit\IteratorMoveNextBodyDebugInfo.cs" />
     <Compile Include="Emit\StateMachineMoveNextDebugInfo.cs" />
+    <Compile Include="PEWriter\ExtendedPEBuilder.cs" />
     <Compile Include="Serialization\IObjectWritable.cs" />
     <Compile Include="Serialization\ObjectBinder.cs" />
     <Compile Include="Serialization\ObjectBinderSnapshot.cs" />
diff --git a/src/Compilers/Core/Portable/PEWriter/ExtendedPEBuilder.cs b/src/Compilers/Core/Portable/PEWriter/ExtendedPEBuilder.cs
new file mode 100755
index 0000000000000..608d66faed3c2
--- /dev/null
+++ b/src/Compilers/Core/Portable/PEWriter/ExtendedPEBuilder.cs
@@ -0,0 +1,100 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Reflection.Metadata;
+using System.Reflection.Metadata.Ecma335;
+using System.Reflection.PortableExecutable;
+using Microsoft.CodeAnalysis;
+
+namespace Microsoft.Cci
+{
+    /// <summary>
+    /// This PEBuilder adds an .mvid section.
+    /// </summary>
+    internal sealed class ExtendedPEBuilder
+        : ManagedPEBuilder
+    {
+        private const string MvidSectionName = ".mvid";
+        public const int SizeOfGuid = 16;
+
+        // When the section is built with a placeholder, the placeholder blob is saved for later fixing up.
+        private Blob _mvidSectionFixup = default(Blob);
+
+        // Only include the .mvid section in ref assemblies
+        private readonly bool _withMvidSection;
+
+        public ExtendedPEBuilder(
+            PEHeaderBuilder header,
+            MetadataRootBuilder metadataRootBuilder,
+            BlobBuilder ilStream,
+            BlobBuilder mappedFieldData,
+            BlobBuilder managedResources,
+            ResourceSectionBuilder nativeResources,
+            DebugDirectoryBuilder debugDirectoryBuilder,
+            int strongNameSignatureSize,
+            MethodDefinitionHandle entryPoint,
+            CorFlags flags,
+            Func<IEnumerable<Blob>, BlobContentId> deterministicIdProvider,
+            bool withMvidSection)
+            : base(header, metadataRootBuilder, ilStream, mappedFieldData, managedResources, nativeResources,
+                  debugDirectoryBuilder, strongNameSignatureSize, entryPoint, flags, deterministicIdProvider)
+        {
+            _withMvidSection = withMvidSection;
+        }
+
+        protected override ImmutableArray<Section> CreateSections()
+        {
+            var baseSections = base.CreateSections();
+
+            if (_withMvidSection)
+            {
+                var builder = ArrayBuilder<Section>.GetInstance(baseSections.Length + 1);
+
+                builder.Add(new Section(MvidSectionName, SectionCharacteristics.MemRead |
+                    SectionCharacteristics.ContainsInitializedData |
+                    SectionCharacteristics.MemDiscardable));
+
+                builder.AddRange(baseSections);
+                return builder.ToImmutableAndFree();
+            }
+            else
+            {
+                return baseSections;
+            }
+        }
+
+        protected override BlobBuilder SerializeSection(string name, SectionLocation location)
+        {
+            if (name.Equals(MvidSectionName, StringComparison.Ordinal))
+            {
+                Debug.Assert(_withMvidSection);
+                return SerializeMvidSection(location);
+            }
+
+            return base.SerializeSection(name, location);
+        }
+
+        internal BlobContentId Serialize(BlobBuilder peBlob, out Blob mvidSectionFixup)
+        {
+            var result = base.Serialize(peBlob);
+            mvidSectionFixup = _mvidSectionFixup;
+            return result;
+        }
+
+        private BlobBuilder SerializeMvidSection(SectionLocation location)
+        {
+            var sectionBuilder = new BlobBuilder();
+
+            // The guid will be filled in later:
+            _mvidSectionFixup = sectionBuilder.ReserveBytes(SizeOfGuid);
+            var mvidWriter = new BlobWriter(_mvidSectionFixup);
+            mvidWriter.WriteBytes(0, _mvidSectionFixup.Length);
+            Debug.Assert(mvidWriter.RemainingBytes == 0);
+
+            return sectionBuilder;
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/PEWriter/PeWriter.cs b/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
index cd9011bb617ab..a84e660f48385 100644
--- a/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
@@ -2,7 +2,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
@@ -69,7 +68,7 @@ internal static bool WritePeToStream(
             MethodDefinitionHandle entryPointHandle;
             MethodDefinitionHandle debugEntryPointHandle;
             mdWriter.GetEntryPoints(out entryPointHandle, out debugEntryPointHandle);
-            
+
             if (!debugEntryPointHandle.IsNil)
             {
                 nativePdbWriterOpt?.SetEntryPoint((uint)MetadataTokens.GetToken(debugEntryPointHandle));
@@ -186,7 +185,7 @@ internal static bool WritePeToStream(
                 debugDirectoryBuilder = null;
             }
 
-            var peBuilder = new ManagedPEBuilder(
+            var peBuilder = new ExtendedPEBuilder(
                 peHeaderBuilder,
                 metadataRootBuilder,
                 ilBuilder,
@@ -197,12 +196,13 @@ internal static bool WritePeToStream(
                 CalculateStrongNameSignatureSize(context.Module),
                 entryPointHandle,
                 properties.CorFlags,
-                deterministicIdProvider);
+                deterministicIdProvider,
+                metadataOnly && !context.IncludePrivateMembers);
 
             var peBlob = new BlobBuilder();
-            var peContentId = peBuilder.Serialize(peBlob);
+            var peContentId = peBuilder.Serialize(peBlob, out Blob mvidSectionFixup);
 
-            PatchModuleVersionIds(mvidFixup, mvidStringFixup, peContentId.Guid);
+            PatchModuleVersionIds(mvidFixup, mvidSectionFixup, mvidStringFixup, peContentId.Guid);
 
             try
             {
@@ -216,7 +216,7 @@ internal static bool WritePeToStream(
             return true;
         }
 
-        private static void PatchModuleVersionIds(Blob guidFixup, Blob stringFixup, Guid mvid)
+        private static void PatchModuleVersionIds(Blob guidFixup, Blob guidSectionFixup, Blob stringFixup, Guid mvid)
         {
             if (!guidFixup.IsDefault)
             {
@@ -225,6 +225,13 @@ private static void PatchModuleVersionIds(Blob guidFixup, Blob stringFixup, Guid
                 Debug.Assert(writer.RemainingBytes == 0);
             }
 
+            if (!guidSectionFixup.IsDefault)
+            {
+                var writer = new BlobWriter(guidSectionFixup);
+                writer.WriteGuid(mvid);
+                Debug.Assert(writer.RemainingBytes == 0);
+            }
+
             if (!stringFixup.IsDefault)
             {
                 var writer = new BlobWriter(stringFixup);

From a255d49117941fbf404ebdbbe6b2635ba1546bd8 Mon Sep 17 00:00:00 2001
From: Rainer Sigwald <raines@microsoft.com>
Date: Wed, 3 May 2017 17:11:48 -0500
Subject: [PATCH 026/284] Introduce ReferencePathWithRefAssemblies parameter to
 CoreCompile target, and shim (#19146)

* Use refasm-only items for compilation

Use the new item provided by common targets to avoid recompiling a
project when a reference has changed only in implementation, not
interface.

Include a shim so that these targets can continue to work on older
MSBuild distributions. That keeps the NuGet-package-for-downlevel
scenario working, as well as making an easy transition period to the new
logic.

Requires Microsoft/msbuild#2039 to enable end-to-end use of reference
assemblies, but is compatible with earlier MSBuilds (without using
reference assemblies).

* Use CopyRefAssembly from NuGet package

The Microsoft.Net.Compilers package delivers UsingTasks to override the
"standard" ones provided by MSBuild's Microsoft.Common.tasks. That
should include the new CopyRefAssembly.
---
 .../Microsoft.Net.Compilers.props             |  2 ++
 .../MSBuildTask/Microsoft.CSharp.Core.targets | 20 +++++++++++++++----
 .../Microsoft.VisualBasic.Core.targets        | 20 +++++++++++++++----
 3 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/build/NuGetAdditionalFiles/Microsoft.Net.Compilers.props b/build/NuGetAdditionalFiles/Microsoft.Net.Compilers.props
index 769370f3a3252..d65f4c022464d 100644
--- a/build/NuGetAdditionalFiles/Microsoft.Net.Compilers.props
+++ b/build/NuGetAdditionalFiles/Microsoft.Net.Compilers.props
@@ -23,6 +23,8 @@
              AssemblyFile="$(MSBuildThisFileDirectory)..\tools\Microsoft.Build.Tasks.CodeAnalysis.dll" />
   <UsingTask TaskName="Microsoft.CodeAnalysis.BuildTasks.Vbc"
              AssemblyFile="$(MSBuildThisFileDirectory)..\tools\Microsoft.Build.Tasks.CodeAnalysis.dll" />
+  <UsingTask TaskName="Microsoft.CodeAnalysis.BuildTasks.CopyRefAssembly"
+             AssemblyFile="$(MSBuildThisFileDirectory)..\tools\Microsoft.Build.Tasks.CodeAnalysis.dll" />
   <PropertyGroup>
     <!-- By default don't use the compiler server in Visual Studio. -->
     <UseSharedCompilation Condition="'$(UseSharedCompilation)' == ''">false</UseSharedCompilation>
diff --git a/src/Compilers/Core/MSBuildTask/Microsoft.CSharp.Core.targets b/src/Compilers/Core/MSBuildTask/Microsoft.CSharp.Core.targets
index 5612c758c3d68..885d32aaaa60c 100644
--- a/src/Compilers/Core/MSBuildTask/Microsoft.CSharp.Core.targets
+++ b/src/Compilers/Core/MSBuildTask/Microsoft.CSharp.Core.targets
@@ -1,13 +1,25 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!-- Copyright (c)  Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information. -->
 <Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Target Name="ShimReferencePathsWhenCommonTargetsDoesNotUnderstandReferenceAssemblies"
+          BeforeTargets="CoreCompile"
+          Condition="'@(ReferencePathWithRefAssemblies)' == ''">
+    <!-- Common targets should populate this item from dev15.3, but this file
+         may be used (via NuGet package) on earlier MSBuilds. If the
+         adjusted-for-reference-assemblies item is not populated, just use
+         the older item's contents. -->
+    <ItemGroup>
+      <ReferencePathWithRefAssemblies Include="@(ReferencePath)" />
+    </ItemGroup>
+  </Target>
+
   <Target Name="CoreCompile"
           Inputs="$(MSBuildAllProjects);
                   @(Compile);
                   @(_CoreCompileResourceInputs);
                   $(ApplicationIcon);
                   $(AssemblyOriginatorKeyFile);
-                  @(ReferencePath);
+                  @(ReferencePathWithRefAssemblies);
                   @(CompiledLicenseFile);
                   @(LinkResource);
                   @(EmbeddedDocumentation);
@@ -38,9 +50,9 @@
     </PropertyGroup>
 
     <ItemGroup Condition="'$(TargetingClr2Framework)' == 'true'">
-      <ReferencePath>
+      <ReferencePathWithRefAssemblies>
         <EmbedInteropTypes />
-      </ReferencePath>
+      </ReferencePathWithRefAssemblies>
     </ItemGroup>
 
     <PropertyGroup>
@@ -117,7 +129,7 @@
          Prefer32Bit="$(Prefer32Bit)"
          PreferredUILang="$(PreferredUILang)"
          ProvideCommandLineArgs="$(ProvideCommandLineArgs)"
-         References="@(ReferencePath)"
+         References="@(ReferencePathWithRefAssemblies)"
          ReportAnalyzer="$(ReportAnalyzer)"
          Resources="@(_CoreCompileResourceInputs);@(CompiledLicenseFile)"
          ResponseFiles="$(CompilerResponseFile)"
diff --git a/src/Compilers/Core/MSBuildTask/Microsoft.VisualBasic.Core.targets b/src/Compilers/Core/MSBuildTask/Microsoft.VisualBasic.Core.targets
index eef272a4b8c59..89249ef700b6b 100644
--- a/src/Compilers/Core/MSBuildTask/Microsoft.VisualBasic.Core.targets
+++ b/src/Compilers/Core/MSBuildTask/Microsoft.VisualBasic.Core.targets
@@ -1,13 +1,25 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!-- Copyright (c)  Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information. -->
 <Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Target Name="ShimReferencePathsWhenCommonTargetsDoesNotUnderstandReferenceAssemblies"
+          BeforeTargets="CoreCompile"
+          Condition="'@(ReferencePathWithRefAssemblies)' == ''">
+    <!-- Common targets should populate this item from dev15.3, but this file
+         may be used (via NuGet package) on earlier MSBuilds. If the
+         adjusted-for-reference-assemblies item is not populated, just use
+         the older item's contents. -->
+    <ItemGroup>
+      <ReferencePathWithRefAssemblies Include="@(ReferencePath)" />
+    </ItemGroup>
+  </Target>
+
   <Target Name="CoreCompile"
           Inputs="$(MSBuildAllProjects);
                   @(Compile);
                   @(_CoreCompileResourceInputs);
                   $(ApplicationIcon);
                   $(AssemblyOriginatorKeyFile);
-                  @(ReferencePath);
+                  @(ReferencePathWithRefAssemblies);
                   @(CompiledLicenseFile);
                   @(LinkResource);
                   @(EmbeddedDocumentation);
@@ -36,9 +48,9 @@
     </PropertyGroup>
 
     <ItemGroup Condition="'$(TargetingClr2Framework)' == 'true'">
-      <ReferencePath>
+      <ReferencePathWithRefAssemblies>
         <EmbedInteropTypes />
-      </ReferencePath>
+      </ReferencePathWithRefAssemblies>
     </ItemGroup>
 
     <!-- Prefer32Bit was introduced in .NET 4.5. Set it to false if we are targeting 4.0 -->
@@ -109,7 +121,7 @@
          Prefer32Bit="$(Prefer32Bit)"
          PreferredUILang="$(PreferredUILang)"
          ProvideCommandLineArgs="$(ProvideCommandLineArgs)"
-         References="@(ReferencePath)"
+         References="@(ReferencePathWithRefAssemblies)"
          RemoveIntegerChecks="$(RemoveIntegerChecks)"
          ReportAnalyzer="$(ReportAnalyzer)"
          Resources="@(_CoreCompileResourceInputs);@(CompiledLicenseFile)"

From 5a155a4fa72bfc518402830a99899cbf6307f0a9 Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam.harwell@microsoft.com>
Date: Thu, 4 May 2017 07:49:14 -0500
Subject: [PATCH 027/284] Verify member is in scope before trying to replace it

---
 .../Extensions/ExpressionSyntaxExtensions.cs  | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs
index 8ebf9a4812d29..87a897aebe7b6 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs
@@ -799,6 +799,25 @@ private static bool TryReduce(
                 }
             }
 
+            // Try to eliminate cases without actually calling CanReplaceWithReducedName. For expressions of the form
+            // 'this.Name' or 'base.Name', no additional check here is required.
+            if (!memberAccess.Expression.IsKind(SyntaxKind.ThisExpression, SyntaxKind.BaseExpression))
+            {
+                var actualSymbol = semanticModel.GetSymbolInfo(memberAccess.Name, cancellationToken);
+                if (actualSymbol.GetAnySymbol() is null)
+                {
+                    return false;
+                }
+
+                // Get a syntax node that's not part of the tree to make sure we speculate on just the name.
+                var speculativeTree = memberAccess.Name.WithoutTrivia();
+                var symbolInfo = semanticModel.GetSpeculativeSymbolInfo(memberAccess.SpanStart, speculativeTree, SpeculativeBindingOption.BindAsExpression);
+                if (!IsReplacementCandidate(actualSymbol, symbolInfo))
+                {
+                    return false;
+                }
+            }
+
             replacementNode = memberAccess.Name
                 .WithLeadingTrivia(memberAccess.GetLeadingTriviaForSimplifiedMemberAccess())
                 .WithTrailingTrivia(memberAccess.GetTrailingTrivia());
@@ -812,6 +831,38 @@ private static bool TryReduce(
             return memberAccess.CanReplaceWithReducedName(replacementNode, semanticModel, cancellationToken);
         }
 
+        /// <summary>
+        /// Determines if <paramref name="speculativeSymbol"/> contains a superset of the symbols in
+        /// <paramref name="actualSymbol"/>.
+        /// </summary>
+        private static bool IsReplacementCandidate(SymbolInfo actualSymbol, SymbolInfo speculativeSymbol)
+        {
+            if (!(speculativeSymbol.Symbol is null))
+            {
+                return Equals(actualSymbol.Symbol, speculativeSymbol.Symbol);
+            }
+
+            if (speculativeSymbol.CandidateSymbols.IsDefault)
+            {
+                return false;
+            }
+
+            if (!(actualSymbol.Symbol is null))
+            {
+                return speculativeSymbol.CandidateSymbols.Contains(actualSymbol.Symbol);
+            }
+
+            foreach (var symbol in actualSymbol.CandidateSymbols)
+            {
+                if (!speculativeSymbol.CandidateSymbols.Contains(symbol))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         private static SyntaxTriviaList GetLeadingTriviaForSimplifiedMemberAccess(this MemberAccessExpressionSyntax memberAccess)
         {
             // We want to include any user-typed trivia that may be present between the 'Expression', 'OperatorToken' and 'Identifier' of the MemberAccessExpression.

From 5d027884c5db500f0cecea0d8b76d9e1dd4b65ba Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam.harwell@microsoft.com>
Date: Thu, 4 May 2017 12:21:51 -0500
Subject: [PATCH 028/284] Allow the Simplify Type Names analyzer to run
 concurrently

---
 .../Analyzers/SimplifyTypeNamesDiagnosticAnalyzerBase.cs        | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Features/Core/Portable/Diagnostics/Analyzers/SimplifyTypeNamesDiagnosticAnalyzerBase.cs b/src/Features/Core/Portable/Diagnostics/Analyzers/SimplifyTypeNamesDiagnosticAnalyzerBase.cs
index cda34277c5b9f..d2c93404d8418 100644
--- a/src/Features/Core/Portable/Diagnostics/Analyzers/SimplifyTypeNamesDiagnosticAnalyzerBase.cs
+++ b/src/Features/Core/Portable/Diagnostics/Analyzers/SimplifyTypeNamesDiagnosticAnalyzerBase.cs
@@ -88,6 +88,8 @@ public bool OpenFileOnly(Workspace workspace)
         public sealed override void Initialize(AnalysisContext context)
         {
             context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+            context.EnableConcurrentExecution();
+
             context.RegisterSyntaxNodeAction(AnalyzeNode, _kindsOfInterest);
         }
 

From 5546f8614809ac00a7b0502957a11b5a54f87212 Mon Sep 17 00:00:00 2001
From: Alireza Habibi <habibi.alireza@outlook.com>
Date: Thu, 4 May 2017 23:07:09 +0430
Subject: [PATCH 029/284] Preserve trivia when converting a numeric literal
 base

---
 .../ConvertNumericLiteralTests.cs             | 27 ++++++++++++++++++-
 .../ConvertNumericLiteralTests.vb             | 24 ++++++++++++++++-
 ...rtNumericLiteralCodeRefactoringProvider.cs |  3 ++-
 3 files changed, 51 insertions(+), 3 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs
index 6d0dc701e9814..a1045549a699f 100644
--- a/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs
+++ b/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs
@@ -26,7 +26,7 @@ private async Task TestFixOneAsync(string initial, string expected, Refactoring
             await TestInRegularAndScriptAsync(CreateTreeText("[||]" + initial), CreateTreeText(expected), index: (int)refactoring);
         }
 
-        private string CreateTreeText(string initial)
+        private static string CreateTreeText(string initial)
         {
             return @"class X { void F() { var x = " + initial + @"; } }";
         }
@@ -96,5 +96,30 @@ public async Task TestTypeCharacter()
         {
             await TestFixOneAsync("0x1e5UL", "0b111100101UL", Refactoring.ChangeBase2);
         }
+
+        [WorkItem(19225, "https://github.com/dotnet/roslyn/issues/19225")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertNumericLiteral)]
+        public async Task TestPreserveWhitespaces()
+        {
+            await TestInRegularAndScriptAsync(
+@"class Program
+{
+    void M()
+    {
+        var numbers = new int[] {
+            [||]0x1, 0x2
+        };
+    }
+}",
+@"class Program
+{
+    void M()
+    {
+        var numbers = new int[] {
+            0b1, 0x2
+        };
+    }
+}", index: (int)Refactoring.ChangeBase2, ignoreTrivia: false);
+        }
     }
 }
diff --git a/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb b/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb
index 9af183e810f99..b38d228341454 100644
--- a/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb
@@ -26,7 +26,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeActions.Conver
             Await TestInRegularAndScriptAsync(CreateTreeText("[||]" + initial), CreateTreeText(expected), index:=DirectCast(refactoring, Integer))
         End Function
 
-        Private Function CreateTreeText(initial As String) As String
+        Private Shared Function CreateTreeText(initial As String) As String
             Return "
 Class X
     Sub M()
@@ -89,5 +89,27 @@ End Class"
         Public Async Function TestTypeCharacter() As Task
             Await TestFixOneAsync("&H1e5UL", "&B111100101UL", Refactoring.ChangeBase2)
         End Function
+
+        <WorkItem(19225, "https://github.com/dotnet/roslyn/issues/19225")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertNumericLiteral)>
+        Public Async Function TestPreserveTrivia() As Task
+            Await TestInRegularAndScriptAsync(
+"Class X
+    Sub M()
+        Dim x As Integer() =
+        {
+            [||]&H1, &H2
+        }
+    End Sub
+End Class",
+"Class X
+    Sub M()
+        Dim x As Integer() =
+        {
+            &B1, &H2
+        }
+    End Sub
+End Class", index := Refactoring.ChangeBase2, ignoreTrivia := False)
+        End Function
     End Class
 End Namespace
diff --git a/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs
index 7d88b14b68cc7..51306e6df2871 100644
--- a/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs
@@ -114,7 +114,8 @@ void RegisterRefactoringWithResult(string text, string title)
                 context.RegisterRefactoring(new MyCodeAction(title, c =>
                 {
                     var generator = SyntaxGenerator.GetGenerator(document);
-                    var updatedToken = generator.NumericLiteralToken(text + suffix, (ulong)value);
+                    var updatedToken = generator.NumericLiteralToken(text + suffix, (ulong)value)
+                        .WithTriviaFrom(numericToken);
                     var updatedRoot = root.ReplaceToken(numericToken, updatedToken);
                     return Task.FromResult(document.WithSyntaxRoot(updatedRoot));
                 }));

From e846ff7a8c2322d4a760ba03805aeff8e46cf678 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Thu, 4 May 2017 15:15:15 -0700
Subject: [PATCH 030/284] stop exposing Workspace from
 WorkspaceAnalyzerOptions.

exposing workspace directly cause people to depends on data/service analyzer is not supposed to depend on, also, it sometime access mutable data instead of snapshot of it which analyzer is not supposed to use.

this cut the connection, and expose specific info analyzer is allowed to use in IDE case.
---
 .../Portable/Diagnostics/AnalyzerHelper.cs    | 23 +++---------
 ...cIncrementalAnalyzer.CompilationManager.cs |  2 +-
 .../Diagnostics/WorkspaceAnalyzerOptions.cs   | 36 ++++++++++++++++---
 ...oveUnnecessaryImportsDiagnosticAnalyzer.cs |  5 ++-
 .../Portable/Workspace/Solution/Document.cs   | 13 +++++--
 5 files changed, 50 insertions(+), 29 deletions(-)

diff --git a/src/Features/Core/Portable/Diagnostics/AnalyzerHelper.cs b/src/Features/Core/Portable/Diagnostics/AnalyzerHelper.cs
index c5529b2a81153..131f5a12edec2 100644
--- a/src/Features/Core/Portable/Diagnostics/AnalyzerHelper.cs
+++ b/src/Features/Core/Portable/Diagnostics/AnalyzerHelper.cs
@@ -120,28 +120,15 @@ public static string GetAnalyzerAssemblyName(this DiagnosticAnalyzer analyzer)
             return typeInfo.Assembly.GetName().Name;
         }
 
-        public static async Task<OptionSet> GetDocumentOptionSetAsync(this AnalyzerOptions analyzerOptions, SyntaxTree syntaxTree, CancellationToken cancellationToken)
+        public static Task<OptionSet> GetDocumentOptionSetAsync(this AnalyzerOptions analyzerOptions, SyntaxTree syntaxTree, CancellationToken cancellationToken)
         {
-            var workspace = (analyzerOptions as WorkspaceAnalyzerOptions)?.Workspace;
-            if (workspace == null)
+            var workspaceAnalyzerOptions = analyzerOptions as WorkspaceAnalyzerOptions;
+            if (workspaceAnalyzerOptions == null)
             {
-                return null;
-            }
-
-            var documentId = workspace.CurrentSolution.GetDocumentId(syntaxTree);
-            if (documentId == null)
-            {
-                return workspace.Options;
-            }
-
-            var document = workspace.CurrentSolution.GetDocument(documentId);
-            if (document == null)
-            {
-                return workspace.Options;
+                return SpecializedTasks.Default<OptionSet>();
             }
 
-            var documentOptionSet = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-            return documentOptionSet ?? workspace.Options;
+            return workspaceAnalyzerOptions.GetDocumentOptionSetAsync(syntaxTree, cancellationToken);
         }
 
         internal static void OnAnalyzerException_NoTelemetryLogging(
diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs
index 4e79297b92810..1f1c6b52a9ea4 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs
@@ -118,7 +118,7 @@ private CompilationWithAnalyzersOptions GetAnalyzerOptions(
                 // in IDE, we always set concurrentAnalysis == false otherwise, we can get into thread starvation due to
                 // async being used with syncronous blocking concurrency.
                 return new CompilationWithAnalyzersOptions(
-                    options: new WorkspaceAnalyzerOptions(project.AnalyzerOptions, project.Solution.Workspace),
+                    options: new WorkspaceAnalyzerOptions(project.AnalyzerOptions, project.Solution.Workspace, project.Solution.Options),
                     onAnalyzerException: GetOnAnalyzerException(project.Id),
                     analyzerExceptionFilter: GetAnalyzerExceptionFilter(project),
                     concurrentAnalysis: false,
diff --git a/src/Features/Core/Portable/Diagnostics/WorkspaceAnalyzerOptions.cs b/src/Features/Core/Portable/Diagnostics/WorkspaceAnalyzerOptions.cs
index 641271f47c3ac..a76b22ba2240a 100644
--- a/src/Features/Core/Portable/Diagnostics/WorkspaceAnalyzerOptions.cs
+++ b/src/Features/Core/Portable/Diagnostics/WorkspaceAnalyzerOptions.cs
@@ -1,5 +1,9 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Options;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Diagnostics
@@ -10,13 +14,35 @@ namespace Microsoft.CodeAnalysis.Diagnostics
     /// </summary>
     internal sealed class WorkspaceAnalyzerOptions : AnalyzerOptions
     {
-        public WorkspaceAnalyzerOptions(AnalyzerOptions options, Workspace workspace)
+        private readonly Workspace _workspace;
+        private readonly OptionSet _optionSet;
+
+        public WorkspaceAnalyzerOptions(AnalyzerOptions options, Workspace workspace, OptionSet optionSet)
             : base(options.AdditionalFiles)
         {
-            this.Workspace = workspace;
+            _workspace = workspace;
+            _optionSet = optionSet;
         }
 
-        public Workspace Workspace { get; }
+        public HostWorkspaceServices Services => _workspace.Services;
+
+        public async Task<OptionSet> GetDocumentOptionSetAsync(SyntaxTree syntaxTree, CancellationToken cancellationToken)
+        {
+            var documentId = _workspace.CurrentSolution.GetDocumentId(syntaxTree);
+            if (documentId == null)
+            {
+                return _optionSet;
+            }
+
+            var document = _workspace.CurrentSolution.GetDocument(documentId);
+            if (document == null)
+            {
+                return _optionSet;
+            }
+
+            var documentOptionSet = await document.GetOptionsAsync(_optionSet, cancellationToken).ConfigureAwait(false);
+            return documentOptionSet ?? _optionSet;
+        }
 
         public override bool Equals(object obj)
         {
@@ -27,13 +53,13 @@ public override bool Equals(object obj)
 
             var other = obj as WorkspaceAnalyzerOptions;
             return other != null &&
-                this.Workspace == other.Workspace &&
+                _workspace == other._workspace &&
                 base.Equals(other);
         }
 
         public override int GetHashCode()
         {
-            return Hash.Combine(this.Workspace, base.GetHashCode());
+            return Hash.Combine(_workspace, base.GetHashCode());
         }
     }
 }
diff --git a/src/Features/Core/Portable/RemoveUnnecessaryImports/AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs b/src/Features/Core/Portable/RemoveUnnecessaryImports/AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs
index ed102b125c67a..eb093db70a52d 100644
--- a/src/Features/Core/Portable/RemoveUnnecessaryImports/AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs
+++ b/src/Features/Core/Portable/RemoveUnnecessaryImports/AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs
@@ -69,9 +69,8 @@ private void AnalyzeSemanticModel(SemanticModelAnalysisContext context)
                 return;
             }
 
-            var workspace = workspaceOptions.Workspace;
-            var service = workspace.Services.GetLanguageServices(context.SemanticModel.Compilation.Language)
-                                            .GetService<IUnnecessaryImportsService>();
+            var service = workspaceOptions.Services.GetLanguageServices(context.SemanticModel.Compilation.Language)
+                                                   .GetService<IUnnecessaryImportsService>();
 
             var unnecessaryImports = service.GetUnnecessaryImports(context.SemanticModel, cancellationToken);
             if (unnecessaryImports.Any())
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
index 332c36949261f..27acaaa8ebbe1 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
@@ -464,13 +464,22 @@ private string GetDebuggerDisplay()
         /// </remarks>
         public Task<DocumentOptionSet> GetOptionsAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            return GetOptionsAsync(Project.Solution.Options, cancellationToken);
+        }
+
+        internal Task<DocumentOptionSet> GetOptionsAsync(OptionSet globalOptionSet, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            // TODO: we have this workaround since Solution.Options is not actually snapshot but just return Workspace.Options which violate snapshot model.
+            //       this doesn't validate whether same optionset is given to invalidate the cache or not. this is not new since existing implementation
+            //       also didn't check whether Workspace.Option is same as before or not. all wierd-ness come from the root cause of Solution.Options violating
+            //       snapshot model. once that is fixed, we can remove this workaround
             if (_cachedOptions == null)
             {
                 var newAsyncLazy = new AsyncLazy<DocumentOptionSet>(async c =>
                 {
                     var optionsService = Project.Solution.Workspace.Services.GetRequiredService<IOptionService>();
-                    var optionSet = await optionsService.GetUpdatedOptionSetForDocumentAsync(this, Project.Solution.Options, c).ConfigureAwait(false);
-                    return new DocumentOptionSet(optionSet, Project.Language);
+                    var documentOptionSet = await optionsService.GetUpdatedOptionSetForDocumentAsync(this, globalOptionSet, c).ConfigureAwait(false);
+                    return new DocumentOptionSet(documentOptionSet, Project.Language);
                 }, cacheResult: true);
 
                 Interlocked.CompareExchange(ref _cachedOptions, newAsyncLazy, comparand: null);

From fb8b3793eb390982c9508fa142772756e67e7b03 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Thu, 4 May 2017 15:20:23 -0700
Subject: [PATCH 031/284] removed API in service hub that internally play with
 data (options) in workspace rather than solution snapshot.

now, like other features, analyzer uses snapshot of options rather than mutable one from Workspace.

eventually we should only use OptionSet snapshot embeded in solution rather than one in workspace.
---
 .../Services/SolutionServiceTests.cs          | 77 -------------------
 .../Core/Diagnostics/DiagnosticComputer.cs    | 18 ++++-
 .../Remote/Core/Services/SolutionService.cs   | 31 --------
 .../CodeAnalysisService_Diagnostics.cs        |  7 +-
 .../Shared/ServiceHubServiceBase.cs           |  6 --
 5 files changed, 19 insertions(+), 120 deletions(-)

diff --git a/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs b/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
index 69aebcfb19175..3624063c1e2c8 100644
--- a/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
+++ b/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
@@ -93,53 +93,6 @@ public async Task TestStrongNameProviderEmpty()
             Assert.Equal(((XmlFileResolver)compilationOptions.XmlReferenceResolver).BaseDirectory, null);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
-        public async Task TestCreationWithOption()
-        {
-            var code = @"class Test { void Method() { } }";
-
-            using (var workspace = TestWorkspace.CreateCSharp(code))
-            {
-                var options = new TestOptionSet().WithChangedOption(RemoteHostOptions.RemoteHostTest, true);
-
-                var solution = workspace.CurrentSolution;
-                var service = await GetSolutionServiceAsync(solution);
-
-                var solutionChecksum = await solution.State.GetChecksumAsync(CancellationToken.None);
-                var synched = await service.GetSolutionAsync(solutionChecksum, options, CancellationToken.None);
-
-                Assert.Equal(solutionChecksum, await synched.State.GetChecksumAsync(CancellationToken.None));
-                Assert.Empty(options.GetChangedOptions(synched.Workspace.Options));
-
-                Assert.True(options.GetOption(RemoteHostOptions.RemoteHostTest));
-                Assert.True(synched.Workspace.Options.GetOption(RemoteHostOptions.RemoteHostTest));
-            }
-        }
-
-        [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
-        public async Task TestOptionIsolation()
-        {
-            var code = @"class Test { void Method() { } }";
-
-            using (var workspace = TestWorkspace.CreateCSharp(code))
-            {
-                var solution = workspace.CurrentSolution;
-                var service = await GetSolutionServiceAsync(solution);
-
-                var solutionChecksum = await solution.State.GetChecksumAsync(CancellationToken.None);
-
-                var options = new TestOptionSet().WithChangedOption(RemoteHostOptions.RemoteHostTest, true);
-                var first = await service.GetSolutionAsync(solutionChecksum, options, CancellationToken.None);
-                var second = await service.GetSolutionAsync(solutionChecksum, options.WithChangedOption(RemoteHostOptions.RemoteHostTest, false), CancellationToken.None);
-
-                Assert.Equal(await first.State.GetChecksumAsync(CancellationToken.None), await second.State.GetChecksumAsync(CancellationToken.None));
-
-                // option change shouldn't affect other workspace
-                Assert.True(first.Workspace.Options.GetOption(RemoteHostOptions.RemoteHostTest));
-                Assert.False(second.Workspace.Options.GetOption(RemoteHostOptions.RemoteHostTest));
-            }
-        }
-
         [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
         public async Task TestCache()
         {
@@ -161,36 +114,6 @@ public async Task TestCache()
             }
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
-        public async Task TestCacheWithOption()
-        {
-            var code = @"class Test { void Method() { } }";
-
-            using (var workspace = TestWorkspace.CreateCSharp(code))
-            {
-                var options = new TestOptionSet().WithChangedOption(RemoteHostOptions.RemoteHostTest, true);
-
-                var solution = workspace.CurrentSolution;
-                var service = await GetSolutionServiceAsync(solution);
-
-                var solutionChecksum = await solution.State.GetChecksumAsync(CancellationToken.None);
-
-                var first = await service.GetSolutionAsync(solutionChecksum, options, CancellationToken.None);
-                var second = await service.GetSolutionAsync(solutionChecksum, options, CancellationToken.None);
-
-                // new solutions if option is involved for isolation
-                Assert.False(object.ReferenceEquals(first, second));
-
-                // but semantic of both solution should be same
-                Assert.Equal(await first.State.GetChecksumAsync(CancellationToken.None), await second.State.GetChecksumAsync(CancellationToken.None));
-
-                // also any sub nodes such as projects should be same
-                Assert.True(object.ReferenceEquals(first.Projects.First().State, second.Projects.First().State));
-
-                Assert.True(first.Workspace is TemporaryWorkspace);
-            }
-        }
-
         [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
         public async Task TestUpdatePrimaryWorkspace()
         {
diff --git a/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs b/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs
index 5fb4c61aa0af1..b2d89dc4522c8 100644
--- a/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs
+++ b/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs
@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Diagnostics.Telemetry;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Workspaces.Diagnostics;
 using Roslyn.Utilities;
 
@@ -27,6 +28,7 @@ public DiagnosticComputer(Project project)
 
         public async Task<DiagnosticAnalysisResultMap<string, DiagnosticAnalysisResultBuilder>> GetDiagnosticsAsync(
             IEnumerable<AnalyzerReference> hostAnalyzers,
+            OptionSet options,
             IEnumerable<string> analyzerIds,
             bool reportSuppressedDiagnostics,
             bool logAnalyzerExecutionTime,
@@ -43,13 +45,14 @@ public async Task<DiagnosticAnalysisResultMap<string, DiagnosticAnalysisResultBu
             var cacheService = _project.Solution.Workspace.Services.GetService<IProjectCacheService>();
             using (var cache = cacheService.EnableCaching(_project.Id))
             {
-                return await AnalyzeAsync(analyzerMap, analyzers, reportSuppressedDiagnostics, logAnalyzerExecutionTime, cancellationToken).ConfigureAwait(false);
+                return await AnalyzeAsync(analyzerMap, analyzers, options, reportSuppressedDiagnostics, logAnalyzerExecutionTime, cancellationToken).ConfigureAwait(false);
             }
         }
 
         private async Task<DiagnosticAnalysisResultMap<string, DiagnosticAnalysisResultBuilder>> AnalyzeAsync(
             BidirectionalMap<string, DiagnosticAnalyzer> analyzerMap,
             ImmutableArray<DiagnosticAnalyzer> analyzers,
+            OptionSet options,
             bool reportSuppressedDiagnostics,
             bool logAnalyzerExecutionTime,
             CancellationToken cancellationToken)
@@ -68,7 +71,7 @@ private async Task<DiagnosticAnalysisResultMap<string, DiagnosticAnalysisResultB
             // TODO: can we support analyzerExceptionFilter in remote host? 
             //       right now, host doesn't support watson, we might try to use new NonFatal watson API?
             var analyzerOptions = new CompilationWithAnalyzersOptions(
-                    options: new WorkspaceAnalyzerOptions(_project.AnalyzerOptions, _project.Solution.Workspace),
+                    options: new WorkspaceAnalyzerOptions(_project.AnalyzerOptions, _project.Solution.Workspace, MergeOptions(_project.Solution.Options, options)),
                     onAnalyzerException: OnAnalyzerException,
                     analyzerExceptionFilter: null,
                     concurrentAnalysis: useConcurrent,
@@ -140,5 +143,16 @@ private BidirectionalMap<string, DiagnosticAnalyzer> CreateAnalyzerMap(IEnumerab
             return new BidirectionalMap<string, DiagnosticAnalyzer>(
                 hostAnalyzers.Concat(project.AnalyzerReferences).SelectMany(r => r.GetAnalyzers(project.Language)).Select(a => KeyValuePair.Create(a.GetAnalyzerId(), a)));
         }
+
+        private OptionSet MergeOptions(OptionSet workspaceOptions, OptionSet userOptions)
+        {
+            var newOptions = workspaceOptions;
+            foreach (var key in userOptions.GetChangedOptions(workspaceOptions))
+            {
+                newOptions = newOptions.WithChangedOption(key, userOptions.GetOption(key));
+            }
+
+            return newOptions;
+        }
     }
 }
diff --git a/src/Workspaces/Remote/Core/Services/SolutionService.cs b/src/Workspaces/Remote/Core/Services/SolutionService.cs
index 06502f83c9095..e6a103347048b 100644
--- a/src/Workspaces/Remote/Core/Services/SolutionService.cs
+++ b/src/Workspaces/Remote/Core/Services/SolutionService.cs
@@ -53,26 +53,6 @@ public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, Cancella
             }
         }
 
-        public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, OptionSet optionSet, CancellationToken cancellationToken)
-        {
-            // get solution
-            var baseSolution = await GetSolutionAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
-            if (optionSet == null)
-            {
-                return baseSolution;
-            }
-
-            // since options belong to workspace, we can't share solution
-            // create temporary workspace
-            var tempWorkspace = new TemporaryWorkspace(baseSolution);
-
-            // set merged options
-            tempWorkspace.Options = MergeOptions(tempWorkspace.Options, optionSet);
-
-            // return new solution
-            return tempWorkspace.CurrentSolution;
-        }
-
         public async Task UpdatePrimaryWorkspaceAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
         {
             var currentSolution = s_primaryWorkspace.CurrentSolution;
@@ -91,17 +71,6 @@ public async Task UpdatePrimaryWorkspaceAsync(Checksum solutionChecksum, Cancell
             }
         }
 
-        private OptionSet MergeOptions(OptionSet workspaceOptions, OptionSet userOptions)
-        {
-            var newOptions = workspaceOptions;
-            foreach (var key in userOptions.GetChangedOptions(workspaceOptions))
-            {
-                newOptions = newOptions.WithChangedOption(key, userOptions.GetOption(key));
-            }
-
-            return newOptions;
-        }
-
         private async Task<Solution> CreateSolution_NoLockAsync(Checksum solutionChecksum, Solution baseSolution, CancellationToken cancellationToken)
         {
             var updater = new SolutionCreator(_assetService, baseSolution, cancellationToken);
diff --git a/src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_Diagnostics.cs b/src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_Diagnostics.cs
index aaa77f851e236..a2a5f03a88423 100644
--- a/src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_Diagnostics.cs
+++ b/src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_Diagnostics.cs
@@ -27,16 +27,15 @@ public async Task CalculateDiagnosticsAsync(DiagnosticArguments arguments, strin
             {
                 try
                 {
-                    var optionSet = await RoslynServices.AssetService.GetAssetAsync<OptionSet>(arguments.OptionSetChecksum, CancellationToken).ConfigureAwait(false);
-
                     // entry point for diagnostic service
-                    var solution = await GetSolutionWithSpecificOptionsAsync(optionSet).ConfigureAwait(false);
+                    var solution = await GetSolutionAsync().ConfigureAwait(false);
 
+                    var optionSet = await RoslynServices.AssetService.GetAssetAsync<OptionSet>(arguments.OptionSetChecksum, CancellationToken).ConfigureAwait(false);
                     var projectId = arguments.ProjectId;
                     var analyzers = RoslynServices.AssetService.GetGlobalAssetsOfType<AnalyzerReference>(CancellationToken);
 
                     var result = await (new DiagnosticComputer(solution.GetProject(projectId))).GetDiagnosticsAsync(
-                        analyzers, arguments.AnalyzerIds, arguments.ReportSuppressedDiagnostics, arguments.LogAnalyzerExecutionTime, CancellationToken).ConfigureAwait(false);
+                        analyzers, optionSet, arguments.AnalyzerIds, arguments.ReportSuppressedDiagnostics, arguments.LogAnalyzerExecutionTime, CancellationToken).ConfigureAwait(false);
 
                     await SerializeDiagnosticResultAsync(streamName, result).ConfigureAwait(false);
                 }
diff --git a/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs b/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs
index 36336263409c7..84549a8cfd7d1 100644
--- a/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs
+++ b/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs
@@ -93,12 +93,6 @@ protected Task<Solution> GetSolutionAsync()
             return RoslynServices.SolutionService.GetSolutionAsync(_solutionChecksumOpt, CancellationToken);
         }
 
-        protected Task<Solution> GetSolutionWithSpecificOptionsAsync(OptionSet options)
-        {
-            Contract.ThrowIfNull(_solutionChecksumOpt);
-            return RoslynServices.SolutionService.GetSolutionAsync(_solutionChecksumOpt, options, CancellationToken);
-        }
-
         protected virtual void Dispose(bool disposing)
         {
             // do nothing here

From dcd8fcbc3d2c819ff4f8b4c1aa758efd0ce3359b Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Thu, 4 May 2017 14:05:17 -0700
Subject: [PATCH 032/284] IObjectCreationExpression API Change

There are couple of changes here:
1. API change: `ImmutableArray<ISymbolInitializer> MemberInitializers` is changed to `ImmutableArray<IOperation> Initializers`.
2. Implementation changes:
   1. Instead of returning the member initializers as synthesized ISymbolInitializer nodes, we now return member intializers as IAssignmentExpression nodes. This ensures completeness of IOperation tree.
   2. Now we also return the collection intializer expressions within an object creation expression.

Fixes #18115

There are 2 bugs still affecting this area:
1. #18781: IOperation API shape for collection initializer expressions
2. #19276: Missing Field/Property reference expression nodes in object creation initializer node
---
 .../CSharp/Portable/BoundTree/Expression.cs   |  38 +--
 .../CSharpCompilerSemanticTest.csproj         |   1 +
 ...perationTests_IObjectCreationExpression.cs | 254 +++++++++++++++++
 ...tionTests_IParameterReferenceExpression.cs |  44 +--
 .../IOperationTests_ISymbolInitializer.cs     | 108 -------
 .../Generated/Operations.xml.Generated.cs     |   6 +-
 .../Operations/IObjectCreationExpression.cs   |   4 +-
 .../Portable/Operations/OperationWalker.cs    |   2 +-
 .../Portable/BoundTree/Expression.vb          |  30 +-
 .../Semantic/BasicCompilerSemanticTest.vbproj |   1 +
 ...perationTests_IObjectCreationExpression.vb | 265 ++++++++++++++++++
 ...tionTests_IParameterReferenceExpression.vb |  53 ++--
 .../IOperationTests_ISymbolInitializer.vb     |  94 -------
 .../Compilation/OperationTreeVerifier.cs      |   2 +-
 14 files changed, 590 insertions(+), 312 deletions(-)
 create mode 100644 src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IObjectCreationExpression.cs
 create mode 100644 src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_IObjectCreationExpression.vb

diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index 605ada05830fa..4329f117fca05 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -515,43 +515,7 @@ internal partial class BoundObjectCreationExpression : IObjectCreationExpression
 
         ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder => BoundCall.DeriveArguments(this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Constructor.Parameters, this.Syntax);
 
-        ImmutableArray<ISymbolInitializer> IObjectCreationExpression.MemberInitializers
-        {
-            get
-            {
-                return (ImmutableArray<ISymbolInitializer>)s_memberInitializersMappings.GetValue(this,
-                    objectCreationExpression =>
-                    {
-                        var objectInitializerExpression = this.InitializerExpressionOpt as BoundObjectInitializerExpression;
-                        if (objectInitializerExpression != null)
-                        {
-                            var builder = ArrayBuilder<ISymbolInitializer>.GetInstance(objectInitializerExpression.Initializers.Length);
-                            foreach (var memberAssignment in objectInitializerExpression.Initializers)
-                            {
-                                var assignment = memberAssignment as BoundAssignmentOperator;
-                                var leftSymbol = (assignment?.Left as BoundObjectInitializerMember)?.MemberSymbol;
-
-                                if ((object)leftSymbol == null)
-                                {
-                                    continue;
-                                }
-
-                                switch (leftSymbol.Kind)
-                                {
-                                    case SymbolKind.Field:
-                                        builder.Add(new FieldInitializer(assignment.Syntax, (IFieldSymbol)leftSymbol, assignment.Right));
-                                        break;
-                                    case SymbolKind.Property:
-                                        builder.Add(new PropertyInitializer(assignment.Syntax, (IPropertySymbol)leftSymbol, assignment.Right));
-                                        break;
-                                }
-                            }
-                            return builder.ToImmutableAndFree();
-                        }
-                        return ImmutableArray<ISymbolInitializer>.Empty;
-                    });
-            }
-        }
+        ImmutableArray<IOperation> IObjectCreationExpression.Initializers => GetChildInitializers(this.InitializerExpressionOpt).As<IOperation>();
 
         internal static ImmutableArray<BoundExpression> GetChildInitializers(BoundExpression objectOrCollectionInitializer)
         {
diff --git a/src/Compilers/CSharp/Test/Semantic/CSharpCompilerSemanticTest.csproj b/src/Compilers/CSharp/Test/Semantic/CSharpCompilerSemanticTest.csproj
index 9858091851294..4c1aefc953288 100644
--- a/src/Compilers/CSharp/Test/Semantic/CSharpCompilerSemanticTest.csproj
+++ b/src/Compilers/CSharp/Test/Semantic/CSharpCompilerSemanticTest.csproj
@@ -63,6 +63,7 @@
     <Compile Include="IOperation\IOperationTests_IArgument.cs" />
     <Compile Include="IOperation\IOperationTests_IIfStatement.cs" />
     <Compile Include="IOperation\IOperationTests_IFieldReferenceExpression.cs" />
+    <Compile Include="IOperation\IOperationTests_IObjectCreationExpression.cs" />
     <Compile Include="IOperation\IOperationTests_IParameterReferenceExpression.cs" />
     <Compile Include="IOperation\IOperationTests_ISymbolInitializer.cs" />
     <Compile Include="IOperation\IOperationTests_InvalidExpression.cs" />
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IObjectCreationExpression.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IObjectCreationExpression.cs
new file mode 100644
index 0000000000000..2a5b571057c7d
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IObjectCreationExpression.cs
@@ -0,0 +1,254 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests
+{
+    public partial class IOperationTests : SemanticModelTestBase
+    {
+        [Fact, WorkItem(17588, "https://github.com/dotnet/roslyn/issues/17588")]
+        public void ObjectCreationWithMemberInitializers()
+        {
+            string source = @"
+struct B
+{
+    public bool Field;
+}
+
+class F
+{
+    public int Field;
+    public string Property1 { set; get; }
+    public B Property2 { set; get; }
+}
+
+class C
+{
+    public void M1()
+    /*<bind>*/{
+        var x1 = new F();
+        var x2 = new F() { Field = 2 };
+        var x3 = new F() { Property1 = """" };
+        var x4 = new F() { Property1 = """", Field = 2 };
+        var x5 = new F() { Property2 = new B { Field = true } };
+
+        var e1 = new F() { Property2 = 1 };
+        var e2 = new F() { """" };
+    }/*</bind>*/
+}
+";
+            string expectedOperationTree = @"
+IBlockStatement (7 statements, 7 locals) (OperationKind.BlockStatement, IsInvalid) (Syntax: '{ ... }')
+  Locals: Local_1: F x1
+    Local_2: F x2
+    Local_3: F x3
+    Local_4: F x4
+    Local_5: F x5
+    Local_6: F e1
+    Local_7: F e2
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'var x1 = new F();')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'var x1 = new F();')
+      Variables: Local_1: F x1
+      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'new F()')
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'var x2 = ne ... ield = 2 };')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'var x2 = ne ... ield = 2 };')
+      Variables: Local_1: F x2
+      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'new F() { Field = 2 }')
+          Initializers(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Int32) (Syntax: 'Field = 2')
+              Left: IOperation:  (OperationKind.None) (Syntax: 'Field')
+              Right: ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: '2')
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'var x3 = ne ... ty1 = """" };')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'var x3 = ne ... ty1 = """" };')
+      Variables: Local_1: F x3
+      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'new F() { P ... rty1 = """" }')
+          Initializers(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.String) (Syntax: 'Property1 = """"')
+              Left: IOperation:  (OperationKind.None) (Syntax: 'Property1')
+              Right: ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: """") (Syntax: '""""')
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'var x4 = ne ... ield = 2 };')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'var x4 = ne ... ield = 2 };')
+      Variables: Local_1: F x4
+      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'new F() { P ... Field = 2 }')
+          Initializers(2): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.String) (Syntax: 'Property1 = """"')
+              Left: IOperation:  (OperationKind.None) (Syntax: 'Property1')
+              Right: ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: """") (Syntax: '""""')
+            IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Int32) (Syntax: 'Field = 2')
+              Left: IOperation:  (OperationKind.None) (Syntax: 'Field')
+              Right: ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: '2')
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'var x5 = ne ... = true } };')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'var x5 = ne ... = true } };')
+      Variables: Local_1: F x5
+      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'new F() { P ...  = true } }')
+          Initializers(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: B) (Syntax: 'Property2 = ... ld = true }')
+              Left: IOperation:  (OperationKind.None) (Syntax: 'Property2')
+              Right: IObjectCreationExpression (Constructor: B..ctor()) (OperationKind.ObjectCreationExpression, Type: B) (Syntax: 'new B { Field = true }')
+                  Initializers(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Boolean) (Syntax: 'Field = true')
+                      Left: IOperation:  (OperationKind.None) (Syntax: 'Field')
+                      Right: ILiteralExpression (OperationKind.LiteralExpression, Type: System.Boolean, Constant: True) (Syntax: 'true')
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'var e1 = ne ... rty2 = 1 };')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'var e1 = ne ... rty2 = 1 };')
+      Variables: Local_1: F e1
+      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F, IsInvalid) (Syntax: 'new F() { P ... erty2 = 1 }')
+          Initializers(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: B, IsInvalid) (Syntax: 'Property2 = 1')
+              Left: IOperation:  (OperationKind.None) (Syntax: 'Property2')
+              Right: IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: B, IsInvalid) (Syntax: '1')
+                  ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'var e2 = new F() { """" };')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'var e2 = new F() { """" };')
+      Variables: Local_1: F e2
+      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F, IsInvalid) (Syntax: 'new F() { """" }')
+          Initializers(1): IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid) (Syntax: '""""')
+              Children(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: """") (Syntax: '""""')
+";
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0029: Cannot implicitly convert type 'int' to 'B'
+                //         var e1 = new F() { Property2 = 1 };
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "1").WithArguments("int", "B").WithLocation(24, 40),
+                // CS1922: Cannot initialize type 'F' with a collection initializer because it does not implement 'System.Collections.IEnumerable'
+                //         var e2 = new F() { "" };
+                Diagnostic(ErrorCode.ERR_CollectionInitRequiresIEnumerable, @"{ """" }").WithArguments("F").WithLocation(25, 26)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<BlockSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [Fact, WorkItem(17588, "https://github.com/dotnet/roslyn/issues/17588")]
+        public void ObjectCreationWithCollectionInitializer()
+        {
+            string source = @"
+using System.Collections.Generic;
+
+class C
+{
+	private readonly int field;
+	public void M1(int x)
+	{
+		int y = 0;
+		var x1 = /*<bind>*/new List<int> { x, y, field }/*</bind>*/;
+	}
+}
+";
+            string expectedOperationTree = @"
+IObjectCreationExpression (Constructor: System.Collections.Generic.List<System.Int32>..ctor()) (OperationKind.ObjectCreationExpression, Type: System.Collections.Generic.List<System.Int32>) (Syntax: 'new List<in ...  y, field }')
+  Initializers(3): IOperation:  (OperationKind.None) (Syntax: 'x')
+      Children(1): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+    IOperation:  (OperationKind.None) (Syntax: 'y')
+      Children(1): ILocalReferenceExpression: y (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'y')
+    IOperation:  (OperationKind.None) (Syntax: 'field')
+      Children(1): IFieldReferenceExpression: System.Int32 C.field (OperationKind.FieldReferenceExpression, Type: System.Int32) (Syntax: 'field')
+          Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: C) (Syntax: 'field')
+";
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0649: Field 'C.field' is never assigned to, and will always have its default value 0
+                // 	private readonly int field;
+                Diagnostic(ErrorCode.WRN_UnassignedInternalField, "field").WithArguments("C.field", "0").WithLocation(6, 23)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<ObjectCreationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [Fact, WorkItem(17588, "https://github.com/dotnet/roslyn/issues/17588")]
+        public void ObjectCreationWithNestedCollectionInitializer()
+        {
+            string source = @"
+using System.Collections.Generic;
+using System.Linq;
+
+class C
+{
+    private readonly int field = 0;
+    public void M1(int x)
+    {
+        int y = 0;
+        var x1 = /*<bind>*/new List<List<int>> {
+            new[] { x, y }.ToList(),
+            new List<int> { field }
+        }/*</bind>*/;
+    }
+}
+";
+            string expectedOperationTree = @"
+IObjectCreationExpression (Constructor: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>..ctor()) (OperationKind.ObjectCreationExpression, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>) (Syntax: 'new List<Li ... }')
+  Initializers(2): IOperation:  (OperationKind.None) (Syntax: 'new[] { x, y }.ToList()')
+      Children(1): IInvocationExpression (static System.Collections.Generic.List<System.Int32> System.Linq.Enumerable.ToList<System.Int32>(this System.Collections.Generic.IEnumerable<System.Int32> source)) (OperationKind.InvocationExpression, Type: System.Collections.Generic.List<System.Int32>) (Syntax: 'new[] { x, y }.ToList()')
+          Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: source) (OperationKind.Argument) (Syntax: 'new[] { x, y }')
+              IConversionExpression (ConversionKind.Cast, Implicit) (OperationKind.ConversionExpression, Type: System.Collections.Generic.IEnumerable<System.Int32>) (Syntax: 'new[] { x, y }')
+                IArrayCreationExpression (Element Type: System.Int32) (OperationKind.ArrayCreationExpression, Type: System.Int32[]) (Syntax: 'new[] { x, y }')
+                  Dimension Sizes(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: 'new[] { x, y }')
+                  Initializer: IArrayInitializer (2 elements) (OperationKind.ArrayInitializer) (Syntax: '{ x, y }')
+                      Element Values(2): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+                        ILocalReferenceExpression: y (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'y')
+    IOperation:  (OperationKind.None) (Syntax: 'new List<int> { field }')
+      Children(1): IObjectCreationExpression (Constructor: System.Collections.Generic.List<System.Int32>..ctor()) (OperationKind.ObjectCreationExpression, Type: System.Collections.Generic.List<System.Int32>) (Syntax: 'new List<int> { field }')
+          Initializers(1): IOperation:  (OperationKind.None) (Syntax: 'field')
+              Children(1): IFieldReferenceExpression: System.Int32 C.field (OperationKind.FieldReferenceExpression, Type: System.Int32) (Syntax: 'field')
+                  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: C) (Syntax: 'field')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<ObjectCreationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [Fact, WorkItem(17588, "https://github.com/dotnet/roslyn/issues/17588")]
+        public void ObjectCreationWithMemberAndCollectionInitializers()
+        {
+            string source = @"
+using System.Collections.Generic;
+
+internal class Class
+{
+    public int X { get; set; }
+    public List<int> Y { get; set; }
+    public Dictionary<int, int> Z { get; set; }
+    public Class C { get; set; }
+
+    private readonly int field = 0;
+
+    public void M(int x)
+    {
+        int y = 0;
+        var c = /*<bind>*/new Class() {
+            X = x,
+            Y = { x, y, 3 },
+            Z = { { x, y } },
+            C = { X = field }
+        }/*</bind>*/;
+    }
+}
+";
+            string expectedOperationTree = @"
+IObjectCreationExpression (Constructor: Class..ctor()) (OperationKind.ObjectCreationExpression, Type: Class) (Syntax: 'new Class() ... }')
+  Initializers(4): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Int32) (Syntax: 'X = x')
+      Left: IOperation:  (OperationKind.None) (Syntax: 'X')
+      Right: IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+    IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Collections.Generic.List<System.Int32>) (Syntax: 'Y = { x, y, 3 }')
+      Left: IOperation:  (OperationKind.None) (Syntax: 'Y')
+      Right: IOperation:  (OperationKind.None) (Syntax: '{ x, y, 3 }')
+          Children(3): IOperation:  (OperationKind.None) (Syntax: 'x')
+              Children(1): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+            IOperation:  (OperationKind.None) (Syntax: 'y')
+              Children(1): ILocalReferenceExpression: y (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'y')
+            IOperation:  (OperationKind.None) (Syntax: '3')
+              Children(1): ILiteralExpression (Text: 3) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 3) (Syntax: '3')
+    IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Collections.Generic.Dictionary<System.Int32, System.Int32>) (Syntax: 'Z = { { x, y } }')
+      Left: IOperation:  (OperationKind.None) (Syntax: 'Z')
+      Right: IOperation:  (OperationKind.None) (Syntax: '{ { x, y } }')
+          Children(1): IOperation:  (OperationKind.None) (Syntax: '{ x, y }')
+              Children(2): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+                ILocalReferenceExpression: y (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'y')
+    IAssignmentExpression (OperationKind.AssignmentExpression, Type: Class) (Syntax: 'C = { X = field }')
+      Left: IOperation:  (OperationKind.None) (Syntax: 'C')
+      Right: IOperation:  (OperationKind.None) (Syntax: '{ X = field }')
+          Children(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Int32) (Syntax: 'X = field')
+              Left: IOperation:  (OperationKind.None) (Syntax: 'X')
+              Right: IFieldReferenceExpression: System.Int32 Class.field (OperationKind.FieldReferenceExpression, Type: System.Int32) (Syntax: 'field')
+                  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: Class) (Syntax: 'field')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<ObjectCreationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.cs
index 509772a22f199..9f62943ac058a 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.cs
@@ -165,26 +165,30 @@ public void M(int x, int y, int z)
 ";
             string expectedOperationTree = @"
 IObjectCreationExpression (Constructor: Class..ctor()) (OperationKind.ObjectCreationExpression, Type: Class) (Syntax: 'new Class() ... { X = z } }')
-  Member Initializers(4): IPropertyInitializer (Property: System.Int32 Class.X { get; set; }) (OperationKind.PropertyInitializerInCreation) (Syntax: 'X = x')
-      IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
-    IPropertyInitializer (Property: System.Collections.Generic.List<System.Int32> Class.Y { get; set; }) (OperationKind.PropertyInitializerInCreation) (Syntax: 'Y = { x, y, 3 }')
-      IOperation:  (OperationKind.None) (Syntax: '{ x, y, 3 }')
-        Children(3): IOperation:  (OperationKind.None) (Syntax: 'x')
-            Children(1): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
-          IOperation:  (OperationKind.None) (Syntax: 'y')
-            Children(1): IParameterReferenceExpression: y (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'y')
-          IOperation:  (OperationKind.None) (Syntax: '3')
-            Children(1): ILiteralExpression (Text: 3) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 3) (Syntax: '3')
-    IPropertyInitializer (Property: System.Collections.Generic.Dictionary<System.Int32, System.Int32> Class.Z { get; set; }) (OperationKind.PropertyInitializerInCreation) (Syntax: 'Z = { { x, y } }')
-      IOperation:  (OperationKind.None) (Syntax: '{ { x, y } }')
-        Children(1): IOperation:  (OperationKind.None) (Syntax: '{ x, y }')
-            Children(2): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
-              IParameterReferenceExpression: y (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'y')
-    IPropertyInitializer (Property: Class Class.C { get; set; }) (OperationKind.PropertyInitializerInCreation) (Syntax: 'C = { X = z }')
-      IOperation:  (OperationKind.None) (Syntax: '{ X = z }')
-        Children(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Int32) (Syntax: 'X = z')
-            Left: IOperation:  (OperationKind.None) (Syntax: 'X')
-            Right: IParameterReferenceExpression: z (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'z')
+  Initializers(4): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Int32) (Syntax: 'X = x')
+      Left: IOperation:  (OperationKind.None) (Syntax: 'X')
+      Right: IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+    IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Collections.Generic.List<System.Int32>) (Syntax: 'Y = { x, y, 3 }')
+      Left: IOperation:  (OperationKind.None) (Syntax: 'Y')
+      Right: IOperation:  (OperationKind.None) (Syntax: '{ x, y, 3 }')
+          Children(3): IOperation:  (OperationKind.None) (Syntax: 'x')
+              Children(1): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+            IOperation:  (OperationKind.None) (Syntax: 'y')
+              Children(1): IParameterReferenceExpression: y (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'y')
+            IOperation:  (OperationKind.None) (Syntax: '3')
+              Children(1): ILiteralExpression (Text: 3) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 3) (Syntax: '3')
+    IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Collections.Generic.Dictionary<System.Int32, System.Int32>) (Syntax: 'Z = { { x, y } }')
+      Left: IOperation:  (OperationKind.None) (Syntax: 'Z')
+      Right: IOperation:  (OperationKind.None) (Syntax: '{ { x, y } }')
+          Children(1): IOperation:  (OperationKind.None) (Syntax: '{ x, y }')
+              Children(2): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+                IParameterReferenceExpression: y (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'y')
+    IAssignmentExpression (OperationKind.AssignmentExpression, Type: Class) (Syntax: 'C = { X = z }')
+      Left: IOperation:  (OperationKind.None) (Syntax: 'C')
+      Right: IOperation:  (OperationKind.None) (Syntax: '{ X = z }')
+          Children(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Int32) (Syntax: 'X = z')
+              Left: IOperation:  (OperationKind.None) (Syntax: 'X')
+              Right: IParameterReferenceExpression: z (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'z')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ISymbolInitializer.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ISymbolInitializer.cs
index dbc5ed2c4157d..7dc638e30f762 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ISymbolInitializer.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ISymbolInitializer.cs
@@ -332,113 +332,5 @@ class C
 
             VerifyOperationTreeAndDiagnosticsForTest<EqualsValueClauseSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
-
-        [Fact, WorkItem(17595, "https://github.com/dotnet/roslyn/issues/17595")]
-        public void MemberInitializerCSharp()
-        {
-            string source = @"
-struct B
-{
-    public bool Field;
-}
-
-class F
-{
-    public int Field;
-    public string Property1 { set; get; }
-    public B Property2 { set; get; }
-}
-
-class C
-{
-    public void M1()
-    /*<bind>*/{
-        var x1 = new F();
-        var x2 = new F() { Field = 2 };
-        var x3 = new F() { Property1 = """""""" };
-        var x4 = new F() { Property1 = """""""", Field = 2 };
-        var x5 = new F() { Property2 = new B { Field = true } };
-
-        var e1 = new F() { Property2 = 1 };
-        var e2 = new F() { """""""" };
-    }/*</bind>*/
-}
-";
-            string expectedOperationTree = @"
-IBlockStatement (7 statements, 7 locals) (OperationKind.BlockStatement, IsInvalid) (Syntax: '{ ... }')
-  Locals: Local_1: F x1
-    Local_2: F x2
-    Local_3: F x3
-    Local_4: F x4
-    Local_5: F x5
-    Local_6: F e1
-    Local_7: F e2
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'var x1 = new F();')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'var x1 = new F();')
-      Variables: Local_1: F x1
-      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'new F()')
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'var x2 = ne ... ield = 2 };')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'var x2 = ne ... ield = 2 };')
-      Variables: Local_1: F x2
-      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'new F() { Field = 2 }')
-          Member Initializers(1): IFieldInitializer (Field: System.Int32 F.Field) (OperationKind.FieldInitializerInCreation) (Syntax: 'Field = 2')
-              ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: '2')
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'var x3 = ne ... 1 = """""""" };')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'var x3 = ne ... 1 = """""""" };')
-      Variables: Local_1: F x3
-      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F, IsInvalid) (Syntax: 'new F() { P ... y1 = """""""" }')
-          Member Initializers(1): IPropertyInitializer (Property: System.String F.Property1 { get; set; }) (OperationKind.PropertyInitializerInCreation) (Syntax: 'Property1 = """"')
-              ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: """") (Syntax: '""""')
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'var x4 = ne ... ield = 2 };')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'var x4 = ne ... ield = 2 };')
-      Variables: Local_1: F x4
-      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F, IsInvalid) (Syntax: 'new F() { P ... Field = 2 }')
-          Member Initializers(2): IPropertyInitializer (Property: System.String F.Property1 { get; set; }) (OperationKind.PropertyInitializerInCreation) (Syntax: 'Property1 = """"')
-              ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: """") (Syntax: '""""')
-            IFieldInitializer (Field: System.Int32 F.Field) (OperationKind.FieldInitializerInCreation) (Syntax: 'Field = 2')
-              ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: '2')
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'var x5 = ne ... = true } };')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'var x5 = ne ... = true } };')
-      Variables: Local_1: F x5
-      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'new F() { P ...  = true } }')
-          Member Initializers(1): IPropertyInitializer (Property: B F.Property2 { get; set; }) (OperationKind.PropertyInitializerInCreation) (Syntax: 'Property2 = ... ld = true }')
-              IObjectCreationExpression (Constructor: B..ctor()) (OperationKind.ObjectCreationExpression, Type: B) (Syntax: 'new B { Field = true }')
-                Member Initializers(1): IFieldInitializer (Field: System.Boolean B.Field) (OperationKind.FieldInitializerInCreation) (Syntax: 'Field = true')
-                    ILiteralExpression (OperationKind.LiteralExpression, Type: System.Boolean, Constant: True) (Syntax: 'true')
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'var e1 = ne ... rty2 = 1 };')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'var e1 = ne ... rty2 = 1 };')
-      Variables: Local_1: F e1
-      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F, IsInvalid) (Syntax: 'new F() { P ... erty2 = 1 }')
-          Member Initializers(1): IPropertyInitializer (Property: B F.Property2 { get; set; }) (OperationKind.PropertyInitializerInCreation, IsInvalid) (Syntax: 'Property2 = 1')
-              IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: B, IsInvalid) (Syntax: '1')
-                ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'var e2 = ne ... ) { """""""" };')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'var e2 = ne ... ) { """""""" };')
-      Variables: Local_1: F e2
-      Initializer: IObjectCreationExpression (Constructor: F..ctor()) (OperationKind.ObjectCreationExpression, Type: F, IsInvalid) (Syntax: 'new F() { """""""" }')
-";
-            var expectedDiagnostics = new DiagnosticDescription[] {
-                // CS1003: Syntax error, ',' expected
-                //         var x3 = new F() { Property1 = """" };
-                Diagnostic(ErrorCode.ERR_SyntaxError, @"""""").WithArguments(",", "").WithLocation(20, 42),
-                // CS1003: Syntax error, ',' expected
-                //         var x4 = new F() { Property1 = """", Field = 2 };
-                Diagnostic(ErrorCode.ERR_SyntaxError, @"""""").WithArguments(",", "").WithLocation(21, 42),
-                // CS1003: Syntax error, ',' expected
-                //         var e2 = new F() { """" };
-                Diagnostic(ErrorCode.ERR_SyntaxError, @"""""").WithArguments(",", "").WithLocation(25, 30),
-                // CS0747: Invalid initializer member declarator
-                //         var x3 = new F() { Property1 = """" };
-                Diagnostic(ErrorCode.ERR_InvalidInitializerElementInitializer, @"""""").WithLocation(20, 42),
-                // CS0747: Invalid initializer member declarator
-                //         var x4 = new F() { Property1 = """", Field = 2 };
-                Diagnostic(ErrorCode.ERR_InvalidInitializerElementInitializer, @"""""").WithLocation(21, 42),
-                // CS0029: Cannot implicitly convert type 'int' to 'B'
-                //         var e1 = new F() { Property2 = 1 };
-                Diagnostic(ErrorCode.ERR_NoImplicitConv, "1").WithArguments("int", "B").WithLocation(24, 40)
-            };
-
-            VerifyOperationTreeAndDiagnosticsForTest<BlockSyntax>(source, expectedOperationTree, expectedDiagnostics);
-        }
     }
 }
\ No newline at end of file
diff --git a/src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs b/src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs
index 93bd76bd27283..1188abb551c47 100644
--- a/src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs
+++ b/src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs
@@ -1522,11 +1522,11 @@ public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, T
     /// </remarks>
     internal sealed partial class ObjectCreationExpression : Operation, IHasArgumentsExpression, IObjectCreationExpression
     {
-        public ObjectCreationExpression(IMethodSymbol constructor, ImmutableArray<ISymbolInitializer> memberInitializers, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+        public ObjectCreationExpression(IMethodSymbol constructor, ImmutableArray<IOperation> initializers, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
             base(OperationKind.ObjectCreationExpression, isInvalid, syntax, type, constantValue)
         {
             Constructor = constructor;
-            MemberInitializers = memberInitializers;
+            Initializers = initializers;
         }
         /// <summary>
         /// Constructor to be invoked on the created instance.
@@ -1535,7 +1535,7 @@ public ObjectCreationExpression(IMethodSymbol constructor, ImmutableArray<ISymbo
         /// <summary>
         /// Explicitly-specified member initializers.
         /// </summary>
-        public ImmutableArray<ISymbolInitializer> MemberInitializers { get; }
+        public ImmutableArray<IOperation> Initializers { get; }
         public override void Accept(OperationVisitor visitor)
         {
             visitor.VisitObjectCreationExpression(this);
diff --git a/src/Compilers/Core/Portable/Operations/IObjectCreationExpression.cs b/src/Compilers/Core/Portable/Operations/IObjectCreationExpression.cs
index 9a06dedb54c60..dfe2997af5ae3 100644
--- a/src/Compilers/Core/Portable/Operations/IObjectCreationExpression.cs
+++ b/src/Compilers/Core/Portable/Operations/IObjectCreationExpression.cs
@@ -18,9 +18,9 @@ public interface IObjectCreationExpression : IHasArgumentsExpression
         /// </summary>
         IMethodSymbol Constructor { get; }
         /// <summary>
-        /// Explicitly-specified member initializers.
+        /// List of member or collection initializer expressions in the object initializer, if any.
         /// </summary>
-        ImmutableArray<ISymbolInitializer> MemberInitializers { get; }
+        ImmutableArray<IOperation> Initializers { get; }
     }
 }
 
diff --git a/src/Compilers/Core/Portable/Operations/OperationWalker.cs b/src/Compilers/Core/Portable/Operations/OperationWalker.cs
index aeed5ce40c37d..f9798628922b0 100644
--- a/src/Compilers/Core/Portable/Operations/OperationWalker.cs
+++ b/src/Compilers/Core/Portable/Operations/OperationWalker.cs
@@ -345,7 +345,7 @@ public override void VisitAddressOfExpression(IAddressOfExpression operation)
         public override void VisitObjectCreationExpression(IObjectCreationExpression operation)
         {
             VisitArray(operation.ArgumentsInEvaluationOrder);
-            VisitArray(operation.MemberInitializers);
+            VisitArray(operation.Initializers);
         }
 
         public override void VisitFieldInitializer(IFieldInitializer operation)
diff --git a/src/Compilers/VisualBasic/Portable/BoundTree/Expression.vb b/src/Compilers/VisualBasic/Portable/BoundTree/Expression.vb
index 029f3a6f4c820..73c08fcfe98c0 100644
--- a/src/Compilers/VisualBasic/Portable/BoundTree/Expression.vb
+++ b/src/Compilers/VisualBasic/Portable/BoundTree/Expression.vb
@@ -1155,8 +1155,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
     Friend Partial Class BoundObjectCreationExpression
         Implements IObjectCreationExpression
 
-        Private Shared ReadOnly s_memberInitializersMappings As New System.Runtime.CompilerServices.ConditionalWeakTable(Of BoundObjectCreationExpression, Object)
-
         Private ReadOnly Property IObjectCreationExpression_Constructor As IMethodSymbol Implements IObjectCreationExpression.Constructor
             Get
                 Return Me.ConstructorOpt
@@ -1170,31 +1168,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
 
-        Private ReadOnly Property IObjectCreationExpression_MemberInitializers As ImmutableArray(Of ISymbolInitializer) Implements IObjectCreationExpression.MemberInitializers
-            Get
-                Dim initializer = s_memberInitializersMappings.GetValue(Me, Function(objectCreationStatement)
-                                                                                Dim objectInitializerExpression As BoundObjectInitializerExpressionBase = Me.InitializerOpt
-                                                                                If objectInitializerExpression IsNot Nothing Then
-                                                                                    Dim builder = ArrayBuilder(Of ISymbolInitializer).GetInstance(objectInitializerExpression.Initializers.Length)
-                                                                                    For Each memberAssignment In objectInitializerExpression.Initializers
-                                                                                        Dim assignment = TryCast(memberAssignment, BoundAssignmentOperator)
-                                                                                        Dim left = assignment?.Left
-                                                                                        If left IsNot Nothing Then
-                                                                                            Select Case left.Kind
-                                                                                                Case BoundKind.FieldAccess
-                                                                                                    builder.Add(New FieldInitializer(assignment.Syntax, DirectCast(left, BoundFieldAccess).FieldSymbol, assignment.Right))
-                                                                                                Case BoundKind.PropertyAccess
-                                                                                                    builder.Add(New PropertyInitializer(assignment.Syntax, DirectCast(left, BoundPropertyAccess).PropertySymbol, assignment.Right))
-                                                                                            End Select
-                                                                                        End If
-                                                                                    Next
-                                                                                    Return builder.ToImmutableAndFree()
-                                                                                End If
-
-                                                                                Return ImmutableArray(Of ISymbolInitializer).Empty
-                                                                            End Function)
-
-                Return DirectCast(initializer, ImmutableArray(Of ISymbolInitializer))
+        Private ReadOnly Property IObjectCreationExpression_Initializers As ImmutableArray(Of IOperation) Implements IObjectCreationExpression.Initializers
+            Get
+                Return If(Me.InitializerOpt IsNot Nothing, Me.InitializerOpt.Initializers.As(Of IOperation), ImmutableArray(Of IOperation).Empty)
             End Get
         End Property
 
diff --git a/src/Compilers/VisualBasic/Test/Semantic/BasicCompilerSemanticTest.vbproj b/src/Compilers/VisualBasic/Test/Semantic/BasicCompilerSemanticTest.vbproj
index c12ac6254f277..019f9ff3a9530 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/BasicCompilerSemanticTest.vbproj
+++ b/src/Compilers/VisualBasic/Test/Semantic/BasicCompilerSemanticTest.vbproj
@@ -108,6 +108,7 @@
     <Compile Include="Diagnostics\GetDiagnosticsTests.vb" />
     <Compile Include="IOperation\IOperationTests_IArgument.vb" />
     <Compile Include="IOperation\IOperationTests_IFieldReferenceExpression.vb" />
+    <Compile Include="IOperation\IOperationTests_IObjectCreationExpression.vb" />
     <Compile Include="IOperation\IOperationTests_IParameterReferenceExpression.vb" />
     <Compile Include="IOperation\IOperationTests_InvalidStatement.vb" />
     <Compile Include="IOperation\IOperationTests_InvalidExpression.vb" />
diff --git a/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_IObjectCreationExpression.vb b/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_IObjectCreationExpression.vb
new file mode 100644
index 0000000000000..232e15217842b
--- /dev/null
+++ b/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_IObjectCreationExpression.vb
@@ -0,0 +1,265 @@
+' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
+Imports Roslyn.Test.Utilities
+
+Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.Semantics
+
+    Partial Public Class IOperationTests
+        Inherits SemanticModelTestBase
+
+        <Fact, WorkItem(17588, "https://github.com/dotnet/roslyn/issues/17588")>
+        Public Sub ObjectCreationWithMemberInitializers()
+            Dim source = <![CDATA[
+Structure B
+    Public Field As Boolean
+End Structure
+
+Class F
+    Public Field As Integer
+    Public Property Property1() As String
+    Public Property Property2() As B
+End Class
+
+Class C
+    Public Sub M1()'BIND:"Public Sub M1()"
+        Dim x1 = New F()
+        Dim x2 = New F() With {.Field = 2}
+        Dim x3 = New F() With {.Property1 = ""}
+        Dim x4 = New F() With {.Property1 = "", .Field = 2}
+        Dim x5 = New F() With {.Property2 = New B() With {.Field = True}}
+
+        Dim e1 = New F() With {.Property2 = 1}
+        Dim e2 = New F() From {""}
+    End Sub
+End Class]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IBlockStatement (9 statements, 7 locals) (OperationKind.BlockStatement, IsInvalid) (Syntax: 'Public Sub  ... End Sub')
+  Locals: Local_1: x1 As F
+    Local_2: x2 As F
+    Local_3: x3 As F
+    Local_4: x4 As F
+    Local_5: x5 As F
+    Local_6: e1 As F
+    Local_7: e2 As F
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'Dim x1 = New F()')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'x1')
+      Variables: Local_1: x1 As F
+      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'New F()')
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'Dim x2 = Ne ... .Field = 2}')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'x2')
+      Variables: Local_1: x2 As F
+      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'New F() Wit ... .Field = 2}')
+          Initializers(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Int32) (Syntax: '.Field = 2')
+              Left: IFieldReferenceExpression: F.Field As System.Int32 (OperationKind.FieldReferenceExpression, Type: System.Int32) (Syntax: 'Field')
+                  Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New F() Wit ... .Field = 2}')
+              Right: ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: '2')
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'Dim x3 = Ne ... erty1 = ""}')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'x3')
+      Variables: Local_1: x3 As F
+      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'New F() Wit ... erty1 = ""}')
+          Initializers(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void) (Syntax: '.Property1 = ""')
+              Left: IIndexedPropertyReferenceExpression: Property F.Property1 As System.String (OperationKind.PropertyReferenceExpression, Type: System.String) (Syntax: 'Property1')
+                  Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New F() Wit ... erty1 = ""}')
+              Right: ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: "") (Syntax: '""')
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'Dim x4 = Ne ... .Field = 2}')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'x4')
+      Variables: Local_1: x4 As F
+      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'New F() Wit ... .Field = 2}')
+          Initializers(2): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void) (Syntax: '.Property1 = ""')
+              Left: IIndexedPropertyReferenceExpression: Property F.Property1 As System.String (OperationKind.PropertyReferenceExpression, Type: System.String) (Syntax: 'Property1')
+                  Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New F() Wit ... .Field = 2}')
+              Right: ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: "") (Syntax: '""')
+            IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Int32) (Syntax: '.Field = 2')
+              Left: IFieldReferenceExpression: F.Field As System.Int32 (OperationKind.FieldReferenceExpression, Type: System.Int32) (Syntax: 'Field')
+                  Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New F() Wit ... .Field = 2}')
+              Right: ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: '2')
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'Dim x5 = Ne ... ld = True}}')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'x5')
+      Variables: Local_1: x5 As F
+      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'New F() Wit ... ld = True}}')
+          Initializers(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void) (Syntax: '.Property2  ... eld = True}')
+              Left: IIndexedPropertyReferenceExpression: Property F.Property2 As B (OperationKind.PropertyReferenceExpression, Type: B) (Syntax: 'Property2')
+                  Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New F() Wit ... ld = True}}')
+              Right: IObjectCreationExpression (Constructor: Sub B..ctor()) (OperationKind.ObjectCreationExpression, Type: B) (Syntax: 'New B() Wit ... eld = True}')
+                  Initializers(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Boolean) (Syntax: '.Field = True')
+                      Left: IFieldReferenceExpression: B.Field As System.Boolean (OperationKind.FieldReferenceExpression, Type: System.Boolean) (Syntax: 'Field')
+                          Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New B() Wit ... eld = True}')
+                      Right: ILiteralExpression (Text: True) (OperationKind.LiteralExpression, Type: System.Boolean, Constant: True) (Syntax: 'True')
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'Dim e1 = Ne ... perty2 = 1}')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'e1')
+      Variables: Local_1: e1 As F
+      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F, IsInvalid) (Syntax: 'New F() Wit ... perty2 = 1}')
+          Initializers(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void, IsInvalid) (Syntax: '.Property2 = 1')
+              Left: IIndexedPropertyReferenceExpression: Property F.Property2 As B (OperationKind.PropertyReferenceExpression, Type: B) (Syntax: 'Property2')
+                  Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New F() Wit ... perty2 = 1}')
+              Right: IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: B, IsInvalid) (Syntax: '1')
+                  ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
+  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'Dim e2 = Ne ... ) From {""}')
+    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'e2')
+      Variables: Local_1: e2 As F
+      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F, IsInvalid) (Syntax: 'New F() From {""}')
+          Initializers(1): IInvalidExpression (OperationKind.InvalidExpression, Type: ?, IsInvalid) (Syntax: '""')
+              Children(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: "") (Syntax: '""')
+  ILabelStatement (Label: exit) (OperationKind.LabelStatement) (Syntax: 'End Sub')
+  IReturnStatement (OperationKind.ReturnStatement) (Syntax: 'End Sub')
+]]>.Value
+
+            Dim expectedDiagnostics = <![CDATA[
+BC30311: Value of type 'Integer' cannot be converted to 'B'.
+        Dim e1 = New F() With {.Property2 = 1}
+                                            ~
+BC36718: Cannot initialize the type 'F' with a collection initializer because it is not a collection type.
+        Dim e2 = New F() From {""}
+                         ~~~~~~~~~
+]]>.Value
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of MethodBlockSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <Fact, WorkItem(17588, "https://github.com/dotnet/roslyn/issues/17588")>
+        Public Sub ObjectCreationWithCollectionInitializer()
+            Dim source = <![CDATA[
+Imports System.Collections.Generic
+
+Class C
+    Private ReadOnly field As Integer
+
+    Public Sub M1(x As Integer)
+        Dim y As Integer = 0
+        Dim x1 = New List(Of Integer) From {x, y, field}'BIND:"New List(Of Integer) From {x, y, field}"
+    End Sub
+End Class]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IObjectCreationExpression (Constructor: Sub System.Collections.Generic.List(Of System.Int32)..ctor()) (OperationKind.ObjectCreationExpression, Type: System.Collections.Generic.List(Of System.Int32)) (Syntax: 'New List(Of ... , y, field}')
+  Initializers(3): IInvocationExpression ( Sub System.Collections.Generic.List(Of System.Int32).Add(item As System.Int32)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'x')
+      Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New List(Of ... , y, field}')
+      Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument) (Syntax: 'x')
+          IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+    IInvocationExpression ( Sub System.Collections.Generic.List(Of System.Int32).Add(item As System.Int32)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'y')
+      Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New List(Of ... , y, field}')
+      Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument) (Syntax: 'y')
+          ILocalReferenceExpression: y (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'y')
+    IInvocationExpression ( Sub System.Collections.Generic.List(Of System.Int32).Add(item As System.Int32)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'field')
+      Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New List(Of ... , y, field}')
+      Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument) (Syntax: 'field')
+          IFieldReferenceExpression: C.field As System.Int32 (OperationKind.FieldReferenceExpression, Type: System.Int32) (Syntax: 'field')
+            Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: C) (Syntax: 'field')
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of ObjectCreationExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <Fact, WorkItem(17588, "https://github.com/dotnet/roslyn/issues/17588")>
+        Public Sub ObjectCreationWithNestedCollectionInitializer()
+            Dim source = <![CDATA[
+Imports System.Collections.Generic
+Imports System.Linq
+
+Class C
+    Private ReadOnly field As Integer
+
+    Public Sub M1(x As Integer)
+        Dim y As Integer = 0
+        Dim x1 = New List(Of List(Of Integer)) From {{x, y}.ToList, New List(Of Integer) From {field}}'BIND:"New List(Of List(Of Integer)) From {{x, y}.ToList, New List(Of Integer) From {field}}"
+    End Sub
+End Class]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IObjectCreationExpression (Constructor: Sub System.Collections.Generic.List(Of System.Collections.Generic.List(Of System.Int32))..ctor()) (OperationKind.ObjectCreationExpression, Type: System.Collections.Generic.List(Of System.Collections.Generic.List(Of System.Int32))) (Syntax: 'New List(Of ... om {field}}')
+  Initializers(2): IInvocationExpression ( Sub System.Collections.Generic.List(Of System.Collections.Generic.List(Of System.Int32)).Add(item As System.Collections.Generic.List(Of System.Int32))) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: '{x, y}.ToList')
+      Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New List(Of ... om {field}}')
+      Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument) (Syntax: '{x, y}.ToList')
+          IInvocationExpression ( Function System.Collections.Generic.IEnumerable(Of System.Int32).ToList() As System.Collections.Generic.List(Of System.Int32)) (OperationKind.InvocationExpression, Type: System.Collections.Generic.List(Of System.Int32)) (Syntax: '{x, y}.ToList')
+            Instance Receiver: IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: System.Collections.Generic.IEnumerable(Of System.Int32)) (Syntax: '{x, y}')
+                IArrayCreationExpression (Element Type: System.Int32) (OperationKind.ArrayCreationExpression, Type: System.Int32()) (Syntax: '{x, y}')
+                  Dimension Sizes(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: '{x, y}')
+                  Initializer: IArrayInitializer (2 elements) (OperationKind.ArrayInitializer) (Syntax: '{x, y}')
+                      Element Values(2): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+                        ILocalReferenceExpression: y (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'y')
+    IInvocationExpression ( Sub System.Collections.Generic.List(Of System.Collections.Generic.List(Of System.Int32)).Add(item As System.Collections.Generic.List(Of System.Int32))) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'New List(Of ... rom {field}')
+      Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New List(Of ... om {field}}')
+      Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument) (Syntax: 'New List(Of ... rom {field}')
+          IObjectCreationExpression (Constructor: Sub System.Collections.Generic.List(Of System.Int32)..ctor()) (OperationKind.ObjectCreationExpression, Type: System.Collections.Generic.List(Of System.Int32)) (Syntax: 'New List(Of ... rom {field}')
+            Initializers(1): IInvocationExpression ( Sub System.Collections.Generic.List(Of System.Int32).Add(item As System.Int32)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'field')
+                Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New List(Of ... rom {field}')
+                Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument) (Syntax: 'field')
+                    IFieldReferenceExpression: C.field As System.Int32 (OperationKind.FieldReferenceExpression, Type: System.Int32) (Syntax: 'field')
+                      Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: C) (Syntax: 'field')
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of ObjectCreationExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <Fact, WorkItem(17588, "https://github.com/dotnet/roslyn/issues/17588")>
+        Public Sub ObjectCreationWithMemberAndCollectionInitializers()
+            Dim source = <![CDATA[
+Imports System.Collections.Generic
+
+Friend Class [Class]
+    Public Property X As Integer
+    Public Property Y As Integer()
+    Public Property Z As Dictionary(Of Integer, Integer)
+    Public Property C As [Class]
+
+    Private ReadOnly field As Integer
+
+    Public Sub M(x As Integer)
+        Dim y As Integer = 0
+        Dim c = New [Class]() With {'BIND:"New [Class]() With {"
+            .X = x,
+            .Y = {x, y, 3},
+            .Z = New Dictionary(Of Integer, Integer) From {{x, y}},
+            .C = New [Class]() With {.X = field}
+        }
+    End Sub
+End Class]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IObjectCreationExpression (Constructor: Sub [Class]..ctor()) (OperationKind.ObjectCreationExpression, Type: [Class]) (Syntax: 'New [Class] ... }')
+  Initializers(4): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void) (Syntax: '.X = x')
+      Left: IIndexedPropertyReferenceExpression: Property [Class].X As System.Int32 (OperationKind.PropertyReferenceExpression, Type: System.Int32) (Syntax: 'X')
+          Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New [Class] ... }')
+      Right: IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+    IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void) (Syntax: '.Y = {x, y, 3}')
+      Left: IIndexedPropertyReferenceExpression: Property [Class].Y As System.Int32() (OperationKind.PropertyReferenceExpression, Type: System.Int32()) (Syntax: 'Y')
+          Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New [Class] ... }')
+      Right: IArrayCreationExpression (Element Type: System.Int32) (OperationKind.ArrayCreationExpression, Type: System.Int32()) (Syntax: '{x, y, 3}')
+          Dimension Sizes(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 3) (Syntax: '{x, y, 3}')
+          Initializer: IArrayInitializer (3 elements) (OperationKind.ArrayInitializer) (Syntax: '{x, y, 3}')
+              Element Values(3): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+                ILocalReferenceExpression: y (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'y')
+                ILiteralExpression (Text: 3) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 3) (Syntax: '3')
+    IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void) (Syntax: '.Z = New Di ... om {{x, y}}')
+      Left: IIndexedPropertyReferenceExpression: Property [Class].Z As System.Collections.Generic.Dictionary(Of System.Int32, System.Int32) (OperationKind.PropertyReferenceExpression, Type: System.Collections.Generic.Dictionary(Of System.Int32, System.Int32)) (Syntax: 'Z')
+          Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New [Class] ... }')
+      Right: IObjectCreationExpression (Constructor: Sub System.Collections.Generic.Dictionary(Of System.Int32, System.Int32)..ctor()) (OperationKind.ObjectCreationExpression, Type: System.Collections.Generic.Dictionary(Of System.Int32, System.Int32)) (Syntax: 'New Diction ... om {{x, y}}')
+          Initializers(1): IInvocationExpression ( Sub System.Collections.Generic.Dictionary(Of System.Int32, System.Int32).Add(key As System.Int32, value As System.Int32)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: '{x, y}')
+              Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New Diction ... om {{x, y}}')
+              Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: key) (OperationKind.Argument) (Syntax: 'x')
+                  IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+                IArgument (ArgumentKind.Explicit, Matching Parameter: value) (OperationKind.Argument) (Syntax: 'y')
+                  ILocalReferenceExpression: y (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'y')
+    IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void) (Syntax: '.C = New [C ... .X = field}')
+      Left: IIndexedPropertyReferenceExpression: Property [Class].C As [Class] (OperationKind.PropertyReferenceExpression, Type: [Class]) (Syntax: 'C')
+          Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New [Class] ... }')
+      Right: IObjectCreationExpression (Constructor: Sub [Class]..ctor()) (OperationKind.ObjectCreationExpression, Type: [Class]) (Syntax: 'New [Class] ... .X = field}')
+          Initializers(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void) (Syntax: '.X = field')
+              Left: IIndexedPropertyReferenceExpression: Property [Class].X As System.Int32 (OperationKind.PropertyReferenceExpression, Type: System.Int32) (Syntax: 'X')
+                  Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New [Class] ... .X = field}')
+              Right: IFieldReferenceExpression: [Class].field As System.Int32 (OperationKind.FieldReferenceExpression, Type: System.Int32) (Syntax: 'field')
+                  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: [Class]) (Syntax: 'field')
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of ObjectCreationExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+    End Class
+End Namespace
diff --git a/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.vb b/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.vb
index 65581f7e4b429..e3af89888feb6 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.vb
@@ -226,7 +226,7 @@ IOperation:  (OperationKind.None) (Syntax: 'From y In x ... nto Count()')
             VerifyOperationTreeAndDiagnosticsForTest(Of QueryExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
         End Sub
 
-        <Fact(Skip:="https://github.com/dotnet/roslyn/issues/18781"), WorkItem(8884, "https://github.com/dotnet/roslyn/issues/8884")>
+        <Fact, WorkItem(8884, "https://github.com/dotnet/roslyn/issues/8884")>
         Public Sub ParameterReference_ObjectAndCollectionInitializer()
             Dim source = <![CDATA[
 Imports System.Collections.Generic
@@ -238,33 +238,48 @@ Friend Class [Class]
     Public Property C As [Class]
 
     Public Sub M(x As Integer, y As Integer, z As Integer)
-        Dim c = New [Class]() With {'BIND:"New [Class]() With {"
+        Dim c = New [Class]() With {'BIND:"New [Class]() With {"'BIND:"New [Class]() With {'BIND:"New [Class]() With {""
             .X = x,
             .Y = {x, y, 3},
             .Z = New Dictionary(Of Integer, Integer) From {{x, y}},
             .C = New [Class]() With {.X = z}
         }
     End Sub
-End Class
-]]>.Value
+End Class]]>.Value
 
             Dim expectedOperationTree = <![CDATA[
 IObjectCreationExpression (Constructor: Sub [Class]..ctor()) (OperationKind.ObjectCreationExpression, Type: [Class]) (Syntax: 'New [Class] ... }')
-  Member Initializers(4): IPropertyInitializer (Property: Property [Class].X As System.Int32) (OperationKind.PropertyInitializerInCreation) (Syntax: '.X = x')
-      IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
-    IPropertyInitializer (Property: Property [Class].Y As System.Int32()) (OperationKind.PropertyInitializerInCreation) (Syntax: '.Y = {x, y, 3}')
-      IArrayCreationExpression (Element Type: System.Int32) (OperationKind.ArrayCreationExpression, Type: System.Int32()) (Syntax: '{x, y, 3}')
-        Dimension Sizes(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 3) (Syntax: '{x, y, 3}')
-        Initializer: IArrayInitializer (3 elements) (OperationKind.ArrayInitializer) (Syntax: '{x, y, 3}')
-            Element Values(3): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
-              IParameterReferenceExpression: y (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'y')
-              ILiteralExpression (Text: 3) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 3) (Syntax: '3')
-    IPropertyInitializer (Property: Property [Class].Z As System.Collections.Generic.Dictionary(Of System.Int32, System.Int32)) (OperationKind.PropertyInitializerInCreation) (Syntax: '.Z = New Di ... om {{x, y}}')
-      IObjectCreationExpression (Constructor: Sub System.Collections.Generic.Dictionary(Of System.Int32, System.Int32)..ctor()) (OperationKind.ObjectCreationExpression, Type: System.Collections.Generic.Dictionary(Of System.Int32, System.Int32)) (Syntax: 'New Diction ... om {{x, y}}')
-    IPropertyInitializer (Property: Property [Class].C As [Class]) (OperationKind.PropertyInitializerInCreation) (Syntax: '.C = New [C ... th {.X = z}')
-      IObjectCreationExpression (Constructor: Sub [Class]..ctor()) (OperationKind.ObjectCreationExpression, Type: [Class]) (Syntax: 'New [Class] ... th {.X = z}')
-        Member Initializers(1): IPropertyInitializer (Property: Property [Class].X As System.Int32) (OperationKind.PropertyInitializerInCreation) (Syntax: '.X = z')
-            IParameterReferenceExpression: z (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'z')
+  Initializers(4): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void) (Syntax: '.X = x')
+      Left: IIndexedPropertyReferenceExpression: Property [Class].X As System.Int32 (OperationKind.PropertyReferenceExpression, Type: System.Int32) (Syntax: 'X')
+          Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New [Class] ... }')
+      Right: IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+    IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void) (Syntax: '.Y = {x, y, 3}')
+      Left: IIndexedPropertyReferenceExpression: Property [Class].Y As System.Int32() (OperationKind.PropertyReferenceExpression, Type: System.Int32()) (Syntax: 'Y')
+          Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New [Class] ... }')
+      Right: IArrayCreationExpression (Element Type: System.Int32) (OperationKind.ArrayCreationExpression, Type: System.Int32()) (Syntax: '{x, y, 3}')
+          Dimension Sizes(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 3) (Syntax: '{x, y, 3}')
+          Initializer: IArrayInitializer (3 elements) (OperationKind.ArrayInitializer) (Syntax: '{x, y, 3}')
+              Element Values(3): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+                IParameterReferenceExpression: y (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'y')
+                ILiteralExpression (Text: 3) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 3) (Syntax: '3')
+    IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void) (Syntax: '.Z = New Di ... om {{x, y}}')
+      Left: IIndexedPropertyReferenceExpression: Property [Class].Z As System.Collections.Generic.Dictionary(Of System.Int32, System.Int32) (OperationKind.PropertyReferenceExpression, Type: System.Collections.Generic.Dictionary(Of System.Int32, System.Int32)) (Syntax: 'Z')
+          Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New [Class] ... }')
+      Right: IObjectCreationExpression (Constructor: Sub System.Collections.Generic.Dictionary(Of System.Int32, System.Int32)..ctor()) (OperationKind.ObjectCreationExpression, Type: System.Collections.Generic.Dictionary(Of System.Int32, System.Int32)) (Syntax: 'New Diction ... om {{x, y}}')
+          Initializers(1): IInvocationExpression ( Sub System.Collections.Generic.Dictionary(Of System.Int32, System.Int32).Add(key As System.Int32, value As System.Int32)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: '{x, y}')
+              Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New Diction ... om {{x, y}}')
+              Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: key) (OperationKind.Argument) (Syntax: 'x')
+                  IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+                IArgument (ArgumentKind.Explicit, Matching Parameter: value) (OperationKind.Argument) (Syntax: 'y')
+                  IParameterReferenceExpression: y (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'y')
+    IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void) (Syntax: '.C = New [C ... th {.X = z}')
+      Left: IIndexedPropertyReferenceExpression: Property [Class].C As [Class] (OperationKind.PropertyReferenceExpression, Type: [Class]) (Syntax: 'C')
+          Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New [Class] ... }')
+      Right: IObjectCreationExpression (Constructor: Sub [Class]..ctor()) (OperationKind.ObjectCreationExpression, Type: [Class]) (Syntax: 'New [Class] ... th {.X = z}')
+          Initializers(1): IAssignmentExpression (OperationKind.AssignmentExpression, Type: System.Void) (Syntax: '.X = z')
+              Left: IIndexedPropertyReferenceExpression: Property [Class].X As System.Int32 (OperationKind.PropertyReferenceExpression, Type: System.Int32) (Syntax: 'X')
+                  Instance Receiver: IOperation:  (OperationKind.None) (Syntax: 'New [Class] ... th {.X = z}')
+              Right: IParameterReferenceExpression: z (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'z')
 ]]>.Value
 
             Dim expectedDiagnostics = String.Empty
diff --git a/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ISymbolInitializer.vb b/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ISymbolInitializer.vb
index 974d686a259cc..42dcdd99240a6 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ISymbolInitializer.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ISymbolInitializer.vb
@@ -269,99 +269,5 @@ IFieldInitializer (Field: C.i2 As System.Int32) (OperationKind.FieldInitializerA
 
             VerifyOperationTreeAndDiagnosticsForTest(Of EqualsValueSyntax)(source, expectedOperationTree, expectedDiagnostics)
         End Sub
-
-        <Fact, WorkItem(17595, "https://github.com/dotnet/roslyn/issues/17595")>
-        Public Sub MemberInitializer()
-            Dim source = <![CDATA[
-Structure B
-    Public Field As Boolean
-End Structure
-
-Class F
-    Public Field As Integer
-    Public Property Property1() As String
-    Public Property Property2() As B
-End Class
-
-Class C
-    Public Sub M1()'BIND:"Public Sub M1()"
-        Dim x1 = New F()
-        Dim x2 = New F() With {.Field = 2}
-        Dim x3 = New F() With {.Property1 = ""}
-        Dim x4 = New F() With {.Property1 = "", .Field = 2}
-        Dim x5 = New F() With {.Property2 = New B() With {.Field = True}}
-
-        Dim e1 = New F() With {.Property2 = 1}
-        Dim e2 = New F() From {""}
-    End Sub
-End Class]]>.Value
-
-            Dim expectedOperationTree = <![CDATA[
-IBlockStatement (9 statements, 7 locals) (OperationKind.BlockStatement, IsInvalid) (Syntax: 'Public Sub  ... End Sub')
-  Locals: Local_1: x1 As F
-    Local_2: x2 As F
-    Local_3: x3 As F
-    Local_4: x4 As F
-    Local_5: x5 As F
-    Local_6: e1 As F
-    Local_7: e2 As F
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'Dim x1 = New F()')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'x1')
-      Variables: Local_1: x1 As F
-      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'New F()')
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'Dim x2 = Ne ... .Field = 2}')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'x2')
-      Variables: Local_1: x2 As F
-      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'New F() Wit ... .Field = 2}')
-          Member Initializers(1): IFieldInitializer (Field: F.Field As System.Int32) (OperationKind.FieldInitializerInCreation) (Syntax: '.Field = 2')
-              ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: '2')
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'Dim x3 = Ne ... erty1 = ""}')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'x3')
-      Variables: Local_1: x3 As F
-      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'New F() Wit ... erty1 = ""}')
-          Member Initializers(1): IPropertyInitializer (Property: Property F.Property1 As System.String) (OperationKind.PropertyInitializerInCreation) (Syntax: '.Property1 = ""')
-              ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: "") (Syntax: '""')
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'Dim x4 = Ne ... .Field = 2}')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'x4')
-      Variables: Local_1: x4 As F
-      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'New F() Wit ... .Field = 2}')
-          Member Initializers(2): IPropertyInitializer (Property: Property F.Property1 As System.String) (OperationKind.PropertyInitializerInCreation) (Syntax: '.Property1 = ""')
-              ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: "") (Syntax: '""')
-            IFieldInitializer (Field: F.Field As System.Int32) (OperationKind.FieldInitializerInCreation) (Syntax: '.Field = 2')
-              ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: '2')
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement) (Syntax: 'Dim x5 = Ne ... ld = True}}')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'x5')
-      Variables: Local_1: x5 As F
-      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F) (Syntax: 'New F() Wit ... ld = True}}')
-          Member Initializers(1): IPropertyInitializer (Property: Property F.Property2 As B) (OperationKind.PropertyInitializerInCreation) (Syntax: '.Property2  ... eld = True}')
-              IObjectCreationExpression (Constructor: Sub B..ctor()) (OperationKind.ObjectCreationExpression, Type: B) (Syntax: 'New B() Wit ... eld = True}')
-                Member Initializers(1): IFieldInitializer (Field: B.Field As System.Boolean) (OperationKind.FieldInitializerInCreation) (Syntax: '.Field = True')
-                    ILiteralExpression (Text: True) (OperationKind.LiteralExpression, Type: System.Boolean, Constant: True) (Syntax: 'True')
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'Dim e1 = Ne ... perty2 = 1}')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'e1')
-      Variables: Local_1: e1 As F
-      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F, IsInvalid) (Syntax: 'New F() Wit ... perty2 = 1}')
-          Member Initializers(1): IPropertyInitializer (Property: Property F.Property2 As B) (OperationKind.PropertyInitializerInCreation, IsInvalid) (Syntax: '.Property2 = 1')
-              IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: B, IsInvalid) (Syntax: '1')
-                ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
-  IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'Dim e2 = Ne ... ) From {""}')
-    IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 'e2')
-      Variables: Local_1: e2 As F
-      Initializer: IObjectCreationExpression (Constructor: Sub F..ctor()) (OperationKind.ObjectCreationExpression, Type: F, IsInvalid) (Syntax: 'New F() From {""}')
-  ILabelStatement (Label: exit) (OperationKind.LabelStatement) (Syntax: 'End Sub')
-  IReturnStatement (OperationKind.ReturnStatement) (Syntax: 'End Sub')
-]]>.Value
-
-            Dim expectedDiagnostics = <![CDATA[
-BC30311: Value of type 'Integer' cannot be converted to 'B'.
-        Dim e1 = New F() With {.Property2 = 1}
-                                            ~
-BC36718: Cannot initialize the type 'F' with a collection initializer because it is not a collection type.
-        Dim e2 = New F() From {""}
-                         ~~~~~~~~~
-]]>.Value
-
-            VerifyOperationTreeAndDiagnosticsForTest(Of MethodBlockSyntax)(source, expectedOperationTree, expectedDiagnostics)
-        End Sub
     End Class
 End Namespace
diff --git a/src/Test/Utilities/Portable/Compilation/OperationTreeVerifier.cs b/src/Test/Utilities/Portable/Compilation/OperationTreeVerifier.cs
index 95209b461d02a..4a0e6df980f3c 100644
--- a/src/Test/Utilities/Portable/Compilation/OperationTreeVerifier.cs
+++ b/src/Test/Utilities/Portable/Compilation/OperationTreeVerifier.cs
@@ -879,7 +879,7 @@ public override void VisitObjectCreationExpression(IObjectCreationExpression ope
             LogCommonPropertiesAndNewLine(operation);
 
             VisitArguments(operation);
-            VisitArray(operation.MemberInitializers, "Member Initializers", logElementCount: true);
+            VisitArray(operation.Initializers, "Initializers", logElementCount: true);
         }
 
         public override void VisitFieldInitializer(IFieldInitializer operation)

From c0c83bb57608333cb2a0bec23df835df1684c628 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Thu, 4 May 2017 15:23:30 -0700
Subject: [PATCH 033/284] reordered parameters

---
 .../DiagnosticIncrementalAnalyzer.CompilationManager.cs         | 2 +-
 .../Core/Portable/Diagnostics/WorkspaceAnalyzerOptions.cs       | 2 +-
 src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs
index 1f1c6b52a9ea4..1d1e41a0ad5f0 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs
@@ -118,7 +118,7 @@ private CompilationWithAnalyzersOptions GetAnalyzerOptions(
                 // in IDE, we always set concurrentAnalysis == false otherwise, we can get into thread starvation due to
                 // async being used with syncronous blocking concurrency.
                 return new CompilationWithAnalyzersOptions(
-                    options: new WorkspaceAnalyzerOptions(project.AnalyzerOptions, project.Solution.Workspace, project.Solution.Options),
+                    options: new WorkspaceAnalyzerOptions(project.AnalyzerOptions, project.Solution.Options, project.Solution.Workspace),
                     onAnalyzerException: GetOnAnalyzerException(project.Id),
                     analyzerExceptionFilter: GetAnalyzerExceptionFilter(project),
                     concurrentAnalysis: false,
diff --git a/src/Features/Core/Portable/Diagnostics/WorkspaceAnalyzerOptions.cs b/src/Features/Core/Portable/Diagnostics/WorkspaceAnalyzerOptions.cs
index a76b22ba2240a..6bcc2c4d4e32e 100644
--- a/src/Features/Core/Portable/Diagnostics/WorkspaceAnalyzerOptions.cs
+++ b/src/Features/Core/Portable/Diagnostics/WorkspaceAnalyzerOptions.cs
@@ -17,7 +17,7 @@ internal sealed class WorkspaceAnalyzerOptions : AnalyzerOptions
         private readonly Workspace _workspace;
         private readonly OptionSet _optionSet;
 
-        public WorkspaceAnalyzerOptions(AnalyzerOptions options, Workspace workspace, OptionSet optionSet)
+        public WorkspaceAnalyzerOptions(AnalyzerOptions options, OptionSet optionSet, Workspace workspace)
             : base(options.AdditionalFiles)
         {
             _workspace = workspace;
diff --git a/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs b/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs
index b2d89dc4522c8..a9bb623709a98 100644
--- a/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs
+++ b/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs
@@ -71,7 +71,7 @@ private async Task<DiagnosticAnalysisResultMap<string, DiagnosticAnalysisResultB
             // TODO: can we support analyzerExceptionFilter in remote host? 
             //       right now, host doesn't support watson, we might try to use new NonFatal watson API?
             var analyzerOptions = new CompilationWithAnalyzersOptions(
-                    options: new WorkspaceAnalyzerOptions(_project.AnalyzerOptions, _project.Solution.Workspace, MergeOptions(_project.Solution.Options, options)),
+                    options: new WorkspaceAnalyzerOptions(_project.AnalyzerOptions, MergeOptions(_project.Solution.Options, options), _project.Solution.Workspace),
                     onAnalyzerException: OnAnalyzerException,
                     analyzerExceptionFilter: null,
                     concurrentAnalysis: useConcurrent,

From 0f8a97c60889101198c51c8641a9d09fb8beaabb Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Thu, 4 May 2017 15:30:33 -0700
Subject: [PATCH 034/284] removed default value for cancellation token

---
 src/Workspaces/Core/Portable/Workspace/Solution/Document.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
index 27acaaa8ebbe1..9536fd9e46507 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
@@ -467,7 +467,7 @@ private string GetDebuggerDisplay()
             return GetOptionsAsync(Project.Solution.Options, cancellationToken);
         }
 
-        internal Task<DocumentOptionSet> GetOptionsAsync(OptionSet globalOptionSet, CancellationToken cancellationToken = default(CancellationToken))
+        internal Task<DocumentOptionSet> GetOptionsAsync(OptionSet globalOptionSet, CancellationToken cancellationToken)
         {
             // TODO: we have this workaround since Solution.Options is not actually snapshot but just return Workspace.Options which violate snapshot model.
             //       this doesn't validate whether same optionset is given to invalidate the cache or not. this is not new since existing implementation

From 6b832a5b245d701d40b09a84b95df3335b70bc2b Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Thu, 4 May 2017 16:22:44 -0700
Subject: [PATCH 035/284] fix build break.

---
 src/Workspaces/Core/Portable/Options/DocumentOptionSet.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/Core/Portable/Options/DocumentOptionSet.cs b/src/Workspaces/Core/Portable/Options/DocumentOptionSet.cs
index 26704647f2c31..6f7023739c35d 100644
--- a/src/Workspaces/Core/Portable/Options/DocumentOptionSet.cs
+++ b/src/Workspaces/Core/Portable/Options/DocumentOptionSet.cs
@@ -5,7 +5,7 @@
 namespace Microsoft.CodeAnalysis.Options
 {
     /// <summary>
-    /// An <see cref="OptionSet"/> that comes from <see cref="Document.GetOptionsAsync"/>. It behaves just like a normal
+    /// An <see cref="OptionSet"/> that comes from <see cref="Document.GetOptionsAsync(System.Threading.CancellationToken)"/>. It behaves just like a normal
     /// <see cref="OptionSet"/> but remembers which language the <see cref="Document"/> is, so you don't have to
     /// pass that information redundantly when calling <see cref="GetOption{T}(PerLanguageOption{T})"/>.
     /// </summary>

From c08f63b2704cd44cc58db0f7798d4b911a89c773 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Thu, 4 May 2017 22:08:03 -0700
Subject: [PATCH 036/284] Move GenerateVariable types.

---
 .../GenerateVariable/GenerateVariableTests.cs      |  5 ++---
 .../AbstractCrossLanguageUserDiagnosticTest.vb     |  2 +-
 .../AddImport/AddImportCrossLanguageTests.vb       |  4 ++--
 .../AddMissingReferenceTests.vb                    |  4 ++--
 .../Diagnostics/AdditionalFileDiagnosticsTests.vb  |  4 ++--
 .../GenerateEventCrossLanguageTests.vb             |  6 ++----
 .../GenerateConstructorCrossLanguageTests.vb       | 10 +++-------
 .../GenerateMethodCrossLanguageTests.vb            | 10 +++-------
 .../GenerateVariableCrossLanguageTests.vb          | 14 ++++++--------
 .../ImplementInterfaceCrossLanguageTests.vb        |  6 ++----
 .../UseAutoProperty/UseAutoPropertyTests.vb        |  8 ++++----
 .../GenerateVariable/GenerateVariableTests.vb      |  4 ++--
 src/Features/CSharp/Portable/CSharpFeatures.csproj |  2 +-
 .../CSharpGenerateVariableCodeFixProvider.cs}      |  4 ++--
 .../VisualBasic/Portable/BasicFeatures.vbproj      |  2 +-
 .../VisualBasicGenerateVariableCodeFixProvider.vb} |  4 ++--
 16 files changed, 37 insertions(+), 52 deletions(-)
 rename src/Features/CSharp/Portable/{CodeFixes/GenerateVariable/GenerateVariableCodeFixProvider.cs => GenerateVariable/CSharpGenerateVariableCodeFixProvider.cs} (94%)
 rename src/Features/VisualBasic/Portable/{CodeFixes/GenerateVariable/GenerateVariableCodeFixProvider.vb => GenerateVariable/VisualBasicGenerateVariableCodeFixProvider.vb} (95%)

diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
index 9172c5add7590..37ebfc1709bb0 100644
--- a/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
+++ b/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
@@ -6,9 +6,8 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CodeStyle;
-using Microsoft.CodeAnalysis.CSharp.CodeFixes.GenerateVariable;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
-using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.CSharp.GenerateVariable;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Options;
 using Roslyn.Test.Utilities;
@@ -19,7 +18,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.GenerateVar
     public class GenerateVariableTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
     {
         internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
-            => (null, new GenerateVariableCodeFixProvider());
+            => (null, new CSharpGenerateVariableCodeFixProvider());
 
         private readonly CodeStyleOption<bool> onWithInfo = new CodeStyleOption<bool>(true, NotificationOption.Suggestion);
 
diff --git a/src/EditorFeatures/Test2/Diagnostics/AbstractCrossLanguageUserDiagnosticTest.vb b/src/EditorFeatures/Test2/Diagnostics/AbstractCrossLanguageUserDiagnosticTest.vb
index 04fa4f9d90dbd..4ede648ace9cf 100644
--- a/src/EditorFeatures/Test2/Diagnostics/AbstractCrossLanguageUserDiagnosticTest.vb
+++ b/src/EditorFeatures/Test2/Diagnostics/AbstractCrossLanguageUserDiagnosticTest.vb
@@ -19,7 +19,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics
     Partial Public MustInherit Class AbstractCrossLanguageUserDiagnosticTest
         Protected Const DestinationDocument = "DestinationDocument"
 
-        Friend MustOverride Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As Tuple(Of DiagnosticAnalyzer, CodeFixProvider)
+        Friend MustOverride Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As (DiagnosticAnalyzer, CodeFixProvider)
 
         Protected Async Function TestMissing(definition As XElement) As Task
             Using workspace = TestWorkspace.Create(definition)
diff --git a/src/EditorFeatures/Test2/Diagnostics/AddImport/AddImportCrossLanguageTests.vb b/src/EditorFeatures/Test2/Diagnostics/AddImport/AddImportCrossLanguageTests.vb
index 2d6ead9f179e6..e490194bcec32 100644
--- a/src/EditorFeatures/Test2/Diagnostics/AddImport/AddImportCrossLanguageTests.vb
+++ b/src/EditorFeatures/Test2/Diagnostics/AddImport/AddImportCrossLanguageTests.vb
@@ -17,7 +17,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.AddImport
     Public Class AddImportCrossLanguageTests
         Inherits AbstractCrossLanguageUserDiagnosticTest
 
-        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As Tuple(Of DiagnosticAnalyzer, CodeFixProvider)
+        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As (DiagnosticAnalyzer, CodeFixProvider)
             Dim fixer As CodeFixProvider
             If language = LanguageNames.CSharp Then
                 fixer = New CSharpAddImportCodeFixProvider()
@@ -25,7 +25,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.AddImport
                 fixer = New VisualBasicAddImportCodeFixProvider()
             End If
 
-            Return Tuple.Create(Of DiagnosticAnalyzer, CodeFixProvider)(Nothing, fixer)
+            Return (Nothing, fixer)
         End Function
 
         <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddImport)>
diff --git a/src/EditorFeatures/Test2/Diagnostics/AddMissingReference/AddMissingReferenceTests.vb b/src/EditorFeatures/Test2/Diagnostics/AddMissingReference/AddMissingReferenceTests.vb
index c5359645f58bb..a5b278a589829 100644
--- a/src/EditorFeatures/Test2/Diagnostics/AddMissingReference/AddMissingReferenceTests.vb
+++ b/src/EditorFeatures/Test2/Diagnostics/AddMissingReference/AddMissingReferenceTests.vb
@@ -23,13 +23,13 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.AddMissingReferenc
             s_systemXamlAssembly = Assembly.Load("System.Xaml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")
         End Sub
 
-        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As Tuple(Of DiagnosticAnalyzer, CodeFixProvider)
+        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As (DiagnosticAnalyzer, CodeFixProvider)
             Dim fixer As CodeFixProvider =
                 CType(If(language = LanguageNames.CSharp,
                    DirectCast(New CSharpAddMissingReferenceCodeFixProvider(), CodeFixProvider),
                    DirectCast(New VisualBasicAddMissingReferenceCodeFixProvider(), CodeFixProvider)), CodeFixProvider)
 
-            Return Tuple.Create(Of DiagnosticAnalyzer, CodeFixProvider)(Nothing, fixer)
+            Return (Nothing, fixer)
         End Function
 
         <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddMissingReference)>
diff --git a/src/EditorFeatures/Test2/Diagnostics/AdditionalFileDiagnosticsTests.vb b/src/EditorFeatures/Test2/Diagnostics/AdditionalFileDiagnosticsTests.vb
index e7049ffb84628..36694763e8fbd 100644
--- a/src/EditorFeatures/Test2/Diagnostics/AdditionalFileDiagnosticsTests.vb
+++ b/src/EditorFeatures/Test2/Diagnostics/AdditionalFileDiagnosticsTests.vb
@@ -14,8 +14,8 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.AdditionalFiles
     Public Class AdditionalFileDiagnosticsTests
         Inherits AbstractCrossLanguageUserDiagnosticTest
 
-        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As Tuple(Of DiagnosticAnalyzer, CodeFixProvider)
-            Return Tuple.Create(Of DiagnosticAnalyzer, CodeFixProvider)(New AdditionalFileAnalyzer(), New AdditionalFileFixer())
+        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As (DiagnosticAnalyzer, CodeFixProvider)
+            Return (New AdditionalFileAnalyzer(), New AdditionalFileFixer())
         End Function
 
         <WpfFact>
diff --git a/src/EditorFeatures/Test2/Diagnostics/GenerateEvent/GenerateEventCrossLanguageTests.vb b/src/EditorFeatures/Test2/Diagnostics/GenerateEvent/GenerateEventCrossLanguageTests.vb
index a0e2d16a36ec9..91d8cc7c2c881 100644
--- a/src/EditorFeatures/Test2/Diagnostics/GenerateEvent/GenerateEventCrossLanguageTests.vb
+++ b/src/EditorFeatures/Test2/Diagnostics/GenerateEvent/GenerateEventCrossLanguageTests.vb
@@ -8,10 +8,8 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.GenerateEvent
     Public Class GenerateEventCrossLanguageTests
         Inherits AbstractCrossLanguageUserDiagnosticTest
 
-        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As Tuple(Of DiagnosticAnalyzer, CodeFixProvider)
-            Return Tuple.Create(Of DiagnosticAnalyzer, CodeFixProvider)(
-                Nothing,
-                New Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateEvent.GenerateEventCodeFixProvider())
+        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As (DiagnosticAnalyzer, CodeFixProvider)
+            Return (Nothing, New Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateEvent.GenerateEventCodeFixProvider())
         End Function
 
         <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEvent)>
diff --git a/src/EditorFeatures/Test2/Diagnostics/GenerateFromUsage/GenerateConstructorCrossLanguageTests.vb b/src/EditorFeatures/Test2/Diagnostics/GenerateFromUsage/GenerateConstructorCrossLanguageTests.vb
index 7604dc58d3e94..c6e0a1afb6cc9 100644
--- a/src/EditorFeatures/Test2/Diagnostics/GenerateFromUsage/GenerateConstructorCrossLanguageTests.vb
+++ b/src/EditorFeatures/Test2/Diagnostics/GenerateFromUsage/GenerateConstructorCrossLanguageTests.vb
@@ -7,15 +7,11 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.GenerateConstructo
     Partial Public Class GenerateConstructorCrossLanguageTests
         Inherits AbstractCrossLanguageUserDiagnosticTest
 
-        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As Tuple(Of DiagnosticAnalyzer, CodeFixProvider)
+        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As (DiagnosticAnalyzer, CodeFixProvider)
             If language = LanguageNames.CSharp Then
-                Return Tuple.Create(Of DiagnosticAnalyzer, CodeFixProvider)(
-                    Nothing,
-                    New CodeAnalysis.CSharp.GenerateConstructor.GenerateConstructorCodeFixProvider())
+                Return (Nothing, New CodeAnalysis.CSharp.GenerateConstructor.GenerateConstructorCodeFixProvider())
             Else
-                Return Tuple.Create(Of DiagnosticAnalyzer, CodeFixProvider)(
-                    Nothing,
-                    New CodeAnalysis.VisualBasic.GenerateConstructor.GenerateConstructorCodeFixProvider())
+                Return (Nothing, New CodeAnalysis.VisualBasic.GenerateConstructor.GenerateConstructorCodeFixProvider())
             End If
         End Function
 
diff --git a/src/EditorFeatures/Test2/Diagnostics/GenerateFromUsage/GenerateMethodCrossLanguageTests.vb b/src/EditorFeatures/Test2/Diagnostics/GenerateFromUsage/GenerateMethodCrossLanguageTests.vb
index 46bfaf924f1f4..65b36b383a6b1 100644
--- a/src/EditorFeatures/Test2/Diagnostics/GenerateFromUsage/GenerateMethodCrossLanguageTests.vb
+++ b/src/EditorFeatures/Test2/Diagnostics/GenerateFromUsage/GenerateMethodCrossLanguageTests.vb
@@ -15,15 +15,11 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.GenerateMethod
             _outputHelper = outputHelper
         End Sub
 
-        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As Tuple(Of DiagnosticAnalyzer, CodeFixProvider)
+        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As (DiagnosticAnalyzer, CodeFixProvider)
             If language = LanguageNames.CSharp Then
-                Return Tuple.Create(Of DiagnosticAnalyzer, CodeFixProvider)(
-                    Nothing,
-                    New CodeAnalysis.CSharp.CodeFixes.GenerateMethod.GenerateMethodCodeFixProvider())
+                Return (Nothing, New CodeAnalysis.CSharp.CodeFixes.GenerateMethod.GenerateMethodCodeFixProvider())
             Else
-                Return Tuple.Create(Of DiagnosticAnalyzer, CodeFixProvider)(
-                    Nothing,
-                    New CodeAnalysis.VisualBasic.CodeFixes.GenerateMethod.GenerateParameterizedMemberCodeFixProvider())
+                Return (Nothing, New CodeAnalysis.VisualBasic.CodeFixes.GenerateMethod.GenerateParameterizedMemberCodeFixProvider())
             End If
         End Function
 
diff --git a/src/EditorFeatures/Test2/Diagnostics/GenerateFromUsage/GenerateVariableCrossLanguageTests.vb b/src/EditorFeatures/Test2/Diagnostics/GenerateFromUsage/GenerateVariableCrossLanguageTests.vb
index fcdb9bd24b917..3779941678203 100644
--- a/src/EditorFeatures/Test2/Diagnostics/GenerateFromUsage/GenerateVariableCrossLanguageTests.vb
+++ b/src/EditorFeatures/Test2/Diagnostics/GenerateFromUsage/GenerateVariableCrossLanguageTests.vb
@@ -3,7 +3,9 @@
 Imports System.Threading.Tasks
 Imports Microsoft.CodeAnalysis.CodeActions
 Imports Microsoft.CodeAnalysis.CodeFixes
+Imports Microsoft.CodeAnalysis.CSharp.GenerateVariable
 Imports Microsoft.CodeAnalysis.Diagnostics
+Imports Microsoft.CodeAnalysis.VisualBasic.GenerateVariable
 Imports Xunit.Abstractions
 
 Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.GenerateVariable
@@ -16,15 +18,11 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.GenerateVariable
             _outputHelper = outputHelper
         End Sub
 
-        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As Tuple(Of DiagnosticAnalyzer, CodeFixProvider)
+        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As (DiagnosticAnalyzer, CodeFixProvider)
             If language = LanguageNames.CSharp Then
-                Return Tuple.Create(Of DiagnosticAnalyzer, CodeFixProvider)(
-                    Nothing,
-                    New Microsoft.CodeAnalysis.CSharp.CodeFixes.GenerateVariable.GenerateVariableCodeFixProvider())
+                Return (Nothing, New CSharpGenerateVariableCodeFixProvider())
             Else
-                Return Tuple.Create(Of DiagnosticAnalyzer, CodeFixProvider)(
-                    Nothing,
-                    New Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateVariable.GenerateVariableCodeFixProvider())
+                Return (Nothing, New VisualBasicGenerateVariableCodeFixProvider())
             End If
         End Function
 
@@ -67,4 +65,4 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.GenerateVariable
             Await TestAsync(input, expected, onAfterWorkspaceCreated:=Sub(w) w.SetTestLogger(AddressOf _outputHelper.WriteLine))
         End Function
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/EditorFeatures/Test2/Diagnostics/ImplementInterface/ImplementInterfaceCrossLanguageTests.vb b/src/EditorFeatures/Test2/Diagnostics/ImplementInterface/ImplementInterfaceCrossLanguageTests.vb
index 3caf64f61512a..c09f3212a5f5a 100644
--- a/src/EditorFeatures/Test2/Diagnostics/ImplementInterface/ImplementInterfaceCrossLanguageTests.vb
+++ b/src/EditorFeatures/Test2/Diagnostics/ImplementInterface/ImplementInterfaceCrossLanguageTests.vb
@@ -10,13 +10,11 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.ImplementInterface
     Public Class ImplementInterfaceCrossLanguageTests
         Inherits AbstractCrossLanguageUserDiagnosticTest
 
-        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As Tuple(Of DiagnosticAnalyzer, CodeFixProvider)
+        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As (DiagnosticAnalyzer, CodeFixProvider)
             If language = LanguageNames.CSharp Then
                 Throw New NotSupportedException("Please add C# Implement interface tests to CSharpEditorTestTests.csproj. These tests require DiagnosticAnalyzer based test base and are NYI for AbstractCrossLanguageUserDiagnosticTest test base.")
             Else
-                Return Tuple.Create(Of DiagnosticAnalyzer, CodeFixProvider)(
-                    Nothing,
-                    New VisualBasicImplementInterfaceCodeFixProvider())
+                Return (Nothing, New VisualBasicImplementInterfaceCodeFixProvider())
             End If
         End Function
 
diff --git a/src/EditorFeatures/Test2/Diagnostics/UseAutoProperty/UseAutoPropertyTests.vb b/src/EditorFeatures/Test2/Diagnostics/UseAutoProperty/UseAutoPropertyTests.vb
index 7532516d2d58a..43784d1a38d3c 100644
--- a/src/EditorFeatures/Test2/Diagnostics/UseAutoProperty/UseAutoPropertyTests.vb
+++ b/src/EditorFeatures/Test2/Diagnostics/UseAutoProperty/UseAutoPropertyTests.vb
@@ -7,11 +7,11 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.UseAutoProperty
     Public Class UseAutoPropertyTests
         Inherits AbstractCrossLanguageUserDiagnosticTest
 
-        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As Tuple(Of DiagnosticAnalyzer, CodeFixProvider)
+        Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace, language As String) As (DiagnosticAnalyzer, CodeFixProvider)
             If language = LanguageNames.CSharp Then
-                Return New Tuple(Of DiagnosticAnalyzer, CodeFixProvider)(New CSharp.UseAutoProperty.UseAutoPropertyAnalyzer(), New CSharp.UseAutoProperty.UseAutoPropertyCodeFixProvider())
-            ElseIf language = LanguageNames.VisualBasic
-                Return New Tuple(Of DiagnosticAnalyzer, CodeFixProvider)(New VisualBasic.UseAutoProperty.UseAutoPropertyAnalyzer(), New VisualBasic.UseAutoProperty.UseAutoPropertyCodeFixProvider())
+                Return (New CSharp.UseAutoProperty.UseAutoPropertyAnalyzer(), New CSharp.UseAutoProperty.UseAutoPropertyCodeFixProvider())
+            ElseIf language = LanguageNames.VisualBasic Then
+                Return (New VisualBasic.UseAutoProperty.UseAutoPropertyAnalyzer(), New VisualBasic.UseAutoProperty.UseAutoPropertyCodeFixProvider())
             Else
                 Throw New Exception()
             End If
diff --git a/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateVariable/GenerateVariableTests.vb b/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateVariable/GenerateVariableTests.vb
index 60d5195ac1cbc..89c40f3a13061 100644
--- a/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateVariable/GenerateVariableTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateVariable/GenerateVariableTests.vb
@@ -4,14 +4,14 @@ Imports System.Collections.Immutable
 Imports Microsoft.CodeAnalysis.CodeActions
 Imports Microsoft.CodeAnalysis.CodeFixes
 Imports Microsoft.CodeAnalysis.Diagnostics
-Imports Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateVariable
+Imports Microsoft.CodeAnalysis.VisualBasic.GenerateVariable
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics.GenerateVariable
     Public Class GenerateVariableTests
         Inherits AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest
 
         Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace) As (DiagnosticAnalyzer, CodeFixProvider)
-            Return (Nothing, New GenerateVariableCodeFixProvider())
+            Return (Nothing, New VisualBasicGenerateVariableCodeFixProvider())
         End Function
 
         Protected Overrides Function MassageActions(actions As ImmutableArray(Of CodeAction)) As ImmutableArray(Of CodeAction)
diff --git a/src/Features/CSharp/Portable/CSharpFeatures.csproj b/src/Features/CSharp/Portable/CSharpFeatures.csproj
index a15b756b7d3c3..276a40dc7c7b0 100644
--- a/src/Features/CSharp/Portable/CSharpFeatures.csproj
+++ b/src/Features/CSharp/Portable/CSharpFeatures.csproj
@@ -131,7 +131,7 @@
     <Compile Include="CodeFixes\GenerateMethod\GenerateConversionCodeFixProvider.cs" />
     <Compile Include="CodeFixes\GenerateMethod\GenerateMethodCodeFixProvider.cs" />
     <Compile Include="CodeFixes\GenerateType\GenerateTypeCodeFixProvider.cs" />
-    <Compile Include="CodeFixes\GenerateVariable\GenerateVariableCodeFixProvider.cs" />
+    <Compile Include="GenerateVariable\CSharpGenerateVariableCodeFixProvider.cs" />
     <Compile Include="CodeFixes\HideBase\HideBaseCodeFixProvider.AddNewKeywordAction.cs" />
     <Compile Include="CodeFixes\HideBase\HideBaseCodeFixProvider.cs" />
     <Compile Include="CodeFixes\Iterator\CSharpAddYieldCodeFixProvider.cs" />
diff --git a/src/Features/CSharp/Portable/CodeFixes/GenerateVariable/GenerateVariableCodeFixProvider.cs b/src/Features/CSharp/Portable/GenerateVariable/CSharpGenerateVariableCodeFixProvider.cs
similarity index 94%
rename from src/Features/CSharp/Portable/CodeFixes/GenerateVariable/GenerateVariableCodeFixProvider.cs
rename to src/Features/CSharp/Portable/GenerateVariable/CSharpGenerateVariableCodeFixProvider.cs
index a497a99f335f3..0f4563a17eb56 100644
--- a/src/Features/CSharp/Portable/CodeFixes/GenerateVariable/GenerateVariableCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/GenerateVariable/CSharpGenerateVariableCodeFixProvider.cs
@@ -12,11 +12,11 @@
 using Microsoft.CodeAnalysis.GenerateMember.GenerateVariable;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 
-namespace Microsoft.CodeAnalysis.CSharp.CodeFixes.GenerateVariable
+namespace Microsoft.CodeAnalysis.CSharp.GenerateVariable
 {
     [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.GenerateVariable), Shared]
     [ExtensionOrder(After = PredefinedCodeFixProviderNames.GenerateMethod)]
-    internal class GenerateVariableCodeFixProvider : AbstractGenerateMemberCodeFixProvider
+    internal class CSharpGenerateVariableCodeFixProvider : AbstractGenerateMemberCodeFixProvider
     {
         private const string CS1061 = nameof(CS1061); // error CS1061: 'C' does not contain a definition for 'Foo' and no extension method 'Foo' accepting a first argument of type 'C' could be found
         private const string CS0103 = nameof(CS0103); // error CS0103: The name 'Foo' does not exist in the current context
diff --git a/src/Features/VisualBasic/Portable/BasicFeatures.vbproj b/src/Features/VisualBasic/Portable/BasicFeatures.vbproj
index 71f6b35a7f052..95ceadeb0e4dd 100644
--- a/src/Features/VisualBasic/Portable/BasicFeatures.vbproj
+++ b/src/Features/VisualBasic/Portable/BasicFeatures.vbproj
@@ -89,7 +89,7 @@
     <Compile Include="CodeFixes\GenerateEvent\GenerateEventCodeFixProvider.vb" />
     <Compile Include="CodeFixes\GenerateParameterizedMember\GenerateParameterizedMemberCodeFixProvider.vb" />
     <Compile Include="CodeFixes\GenerateType\GenerateTypeCodeFixProvider.vb" />
-    <Compile Include="CodeFixes\GenerateVariable\GenerateVariableCodeFixProvider.vb" />
+    <Compile Include="GenerateVariable\VisualBasicGenerateVariableCodeFixProvider.vb" />
     <Compile Include="CodeFixes\RemoveUnusedVariable\RemoveUnusedVariableCodeFixProvider.vb" />
     <Compile Include="ConvertIfToSwitch\VisualBasicConvertIfToSwitchCodeRefactoringProvider.Pattern.vb" />
     <Compile Include="ConvertIfToSwitch\VisualBasicConvertIfToSwitchCodeRefactoringProvider.vb" />
diff --git a/src/Features/VisualBasic/Portable/CodeFixes/GenerateVariable/GenerateVariableCodeFixProvider.vb b/src/Features/VisualBasic/Portable/GenerateVariable/VisualBasicGenerateVariableCodeFixProvider.vb
similarity index 95%
rename from src/Features/VisualBasic/Portable/CodeFixes/GenerateVariable/GenerateVariableCodeFixProvider.vb
rename to src/Features/VisualBasic/Portable/GenerateVariable/VisualBasicGenerateVariableCodeFixProvider.vb
index 08e48d571ea4a..1d9bc52384e29 100644
--- a/src/Features/VisualBasic/Portable/CodeFixes/GenerateVariable/GenerateVariableCodeFixProvider.vb
+++ b/src/Features/VisualBasic/Portable/GenerateVariable/VisualBasicGenerateVariableCodeFixProvider.vb
@@ -9,10 +9,10 @@ Imports Microsoft.CodeAnalysis.CodeFixes.GenerateMember
 Imports Microsoft.CodeAnalysis.GenerateMember.GenerateVariable
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
-Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateVariable
+Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateVariable
     <ExportCodeFixProvider(LanguageNames.VisualBasic, Name:=PredefinedCodeFixProviderNames.GenerateVariable), [Shared]>
     <ExtensionOrder(After:=PredefinedCodeFixProviderNames.GenerateMethod)>
-    Friend Class GenerateVariableCodeFixProvider
+    Friend Class VisualBasicGenerateVariableCodeFixProvider
         Inherits AbstractGenerateMemberCodeFixProvider
 
         Friend Const BC30456 As String = "BC30456" ' error BC30456: 'Foo' is not a member of 'P'.

From ff703cb1b19bd8e313b012377addc4b316416278 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Thu, 4 May 2017 22:59:22 -0700
Subject: [PATCH 037/284] Add heuristic to prefer generating readonly fields.

---
 .../GenerateVariable/GenerateVariableTests.cs |  54 ++++++++++
 .../AbstractGenerateVariableService.State.cs  | 101 ++++++++++++++++++
 .../AbstractGenerateVariableService.cs        |  40 +++++--
 3 files changed, 188 insertions(+), 7 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
index 37ebfc1709bb0..77b03830cd953 100644
--- a/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
+++ b/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
@@ -7173,6 +7173,60 @@ void M()
     {
         [|nameof|]
     }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
+        public async Task TestPreferReadOnlyIfAfterReadOnlyAssignment()
+        {
+            await TestInRegularAndScriptAsync(
+@"class Class
+{
+    private readonly int _foo;
+
+    public Class()
+    {
+        _foo = 0;
+        [|_bar|] = 1;
+    }
+}",
+@"class Class
+{
+    private readonly int _foo;
+    private readonly int _bar;
+
+    public Class()
+    {
+        _foo = 0;
+        _bar = 1;
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
+        public async Task TestPreferReadOnlyIfBeforeReadOnlyAssignment()
+        {
+            await TestInRegularAndScriptAsync(
+@"class Class
+{
+    private readonly int _foo;
+
+    public Class()
+    {
+        [|_bar|] = 1;
+        _foo = 0;
+    }
+}",
+@"class Class
+{
+    private readonly int _foo;
+    private readonly int _bar;
+
+    public Class()
+    {
+        _bar = 1;
+        _foo = 0;
+    }
 }");
         }
     }
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
index 20b8361c56311..1aee2bf794011 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
@@ -36,6 +37,9 @@ private partial class State
             public ITypeSymbol TypeMemberType { get; private set; }
             public ITypeSymbol LocalType { get; private set; }
 
+            public bool ReadOnlyFieldFirst { get; private set; }
+            public bool ReadOnlyPropertyFirst { get; private set; }
+
             public bool IsWrittenTo { get; private set; }
             public bool IsOnlyWrittenTo { get; private set; }
 
@@ -252,9 +256,106 @@ private bool TryInitializeSimpleName(
                 this.IsInConstructor = DetermineIsInConstructor(document);
                 this.IsInMemberContext = this.SimpleNameOpt != this.SimpleNameOrMemberAccessExpressionOpt ||
                                          syntaxFacts.IsObjectInitializerNamedAssignmentIdentifier(this.SimpleNameOrMemberAccessExpressionOpt);
+
+                this.ReadOnlyPropertyFirst = DetermineReadOnlyFirst(document, SymbolKind.Property, cancellationToken);
+                this.ReadOnlyFieldFirst = DetermineReadOnlyFirst(document, SymbolKind.Field, cancellationToken);
+
                 return true;
             }
 
+            private bool DetermineReadOnlyFirst(
+                SemanticDocument document, SymbolKind symbolKind, CancellationToken cancellationToken)
+            {
+                var syntaxFacts = document.Document.GetLanguageService<ISyntaxFactsService>();
+                var simpleName = this.SimpleNameOpt;
+
+                if (syntaxFacts.IsLeftSideOfAssignment(simpleName))
+                {
+                    var assignment = simpleName.Parent;
+                    if (syntaxFacts.IsSimpleAssignmentStatement(assignment.Parent))
+                    {
+                        var statement = assignment.Parent;
+                        var block = statement.Parent;
+                        var children = block.ChildNodesAndTokens();
+
+                        var statementindex = GetStatementindex(children, statement);
+                        return IsReadOnlyMemberAssignment(document, symbolKind, children, statementindex - 1, cancellationToken) ||
+                               IsReadOnlyMemberAssignment(document, symbolKind, children, statementindex + 1, cancellationToken);
+                    }
+                }
+
+                return false;
+            }
+
+            private bool IsReadOnlyMemberAssignment(
+                SemanticDocument document, SymbolKind symbolKind, 
+                ChildSyntaxList children, int index,
+                CancellationToken cancellationToken)
+            {
+                var syntaxFacts = document.Document.GetLanguageService<ISyntaxFactsService>();
+                if (index >=  0 && index < children.Count)
+                {
+                    var sibling = children[index];
+                    if (sibling.IsNode)
+                    {
+                        var siblingNode = sibling.AsNode();
+                        if (syntaxFacts.IsSimpleAssignmentStatement(siblingNode))
+                        {
+                            syntaxFacts.GetPartsOfAssignmentStatement(
+                                siblingNode, out var left, out var right);
+
+                            var symbol = document.SemanticModel.GetSymbolInfo(left, cancellationToken).Symbol;
+                            if (symbol?.Kind == symbolKind &&
+                                symbol.ContainingType.Equals(this.ContainingType))
+                            {
+                                return IsReadOnly(symbol);
+                            }
+                        }
+                    }
+                }
+
+                return false;
+            }
+
+            private bool IsReadOnly(ISymbol symbol)
+            {
+                switch (symbol)
+                {
+                    case IFieldSymbol field: return field.IsReadOnly;
+                    case IPropertySymbol property:
+                        if (property.SetMethod == null)
+                        {
+                            return true;
+                        }
+
+                        if (property.ContainingType.GetMembers().OfType<IFieldSymbol>().Any(
+                                f => property.SetMethod.Equals(f.AssociatedSymbol)))
+                        {
+                            return true;
+                        }
+
+                        return false;
+                }
+
+                throw ExceptionUtilities.Unreachable;
+            }
+
+            private int GetStatementindex(ChildSyntaxList children, SyntaxNode statement)
+            {
+                var index = 0;
+                foreach (var child in children)
+                {
+                    if (child == statement)
+                    {
+                        return index;
+                    }
+
+                    index++;
+                }
+
+                throw ExceptionUtilities.Unreachable;
+            }
+
             private void DetermineFieldType(
                 SemanticDocument document,
                 CancellationToken cancellationToken)
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs
index 740ca7034edb2..7391afaa4d749 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs
@@ -108,16 +108,29 @@ private void AddPropertyCodeActions(
                 return;
             }
 
-            result.Add(new GenerateVariableCodeAction(
-                (TService)this, document, state, generateProperty: true,
-                isReadonly: false, isConstant: false, returnsByRef: state.IsInRefContext));
+            if (!state.ReadOnlyPropertyFirst)
+            {
+                GenerateWritableProperty(result, document, state);
+            }
 
             if (state.TypeToGenerateIn.TypeKind == TypeKind.Interface && !state.IsWrittenTo)
             {
                 result.Add(new GenerateVariableCodeAction(
-                    (TService)this, document, state, generateProperty: true, 
+                    (TService)this, document, state, generateProperty: true,
                     isReadonly: true, isConstant: false, returnsByRef: state.IsInRefContext));
             }
+
+            if (state.ReadOnlyPropertyFirst)
+            {
+                GenerateWritableProperty(result, document, state);
+            }
+        }
+
+        private void GenerateWritableProperty(ArrayBuilder<CodeAction> result, SemanticDocument document, State state)
+        {
+            result.Add(new GenerateVariableCodeAction(
+                (TService)this, document, state, generateProperty: true,
+                isReadonly: false, isConstant: false, returnsByRef: state.IsInRefContext));
         }
 
         private void AddFieldCodeActions(ArrayBuilder<CodeAction> result, SemanticDocument document, State state)
@@ -132,9 +145,10 @@ private void AddFieldCodeActions(ArrayBuilder<CodeAction> result, SemanticDocume
                 }
                 else
                 {
-                    result.Add(new GenerateVariableCodeAction(
-                        (TService)this, document, state, generateProperty: false,
-                        isReadonly: false, isConstant: false, returnsByRef: false));
+                    if (!state.ReadOnlyFieldFirst)
+                    {
+                        GenerateWriteableField(result, document, state);
+                    }
 
                     // If we haven't written to the field, or we're in the constructor for the type
                     // we're writing into, then we can generate this field read-only.
@@ -144,10 +158,22 @@ private void AddFieldCodeActions(ArrayBuilder<CodeAction> result, SemanticDocume
                             (TService)this, document, state, generateProperty: false,
                             isReadonly: true, isConstant: false, returnsByRef: false));
                     }
+
+                    if (state.ReadOnlyFieldFirst)
+                    {
+                        GenerateWriteableField(result, document, state);
+                    }
                 }
             }
         }
 
+        private void GenerateWriteableField(ArrayBuilder<CodeAction> result, SemanticDocument document, State state)
+        {
+            result.Add(new GenerateVariableCodeAction(
+                (TService)this, document, state, generateProperty: false,
+                isReadonly: false, isConstant: false, returnsByRef: false));
+        }
+
         private void AddLocalCodeActions(ArrayBuilder<CodeAction> result, Document document, State state)
         {
             if (state.CanGenerateLocal())

From 26c708fb2c2463ddbc12fc3c7f67b648a4e65cbf Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Thu, 4 May 2017 23:14:48 -0700
Subject: [PATCH 038/284] Prefer readonly properties in constructors.

---
 .../GenerateVariable/GenerateVariableTests.cs | 65 ++++++++++++++++---
 .../AbstractGenerateVariableService.State.cs  |  2 -
 .../AbstractGenerateVariableService.cs        | 12 +---
 3 files changed, 60 insertions(+), 19 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
index 77b03830cd953..3825d90a66a7b 100644
--- a/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
+++ b/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
@@ -814,7 +814,7 @@ void Method(I i)
 interface I
 {
     object Foo { get; set; }
-}");
+}", index: 1);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
@@ -843,8 +843,7 @@ void Method(I i)
 interface I
 {
     object Foo { get; }
-}",
-index: 1);
+}");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
@@ -1509,7 +1508,7 @@ bool ITest.SomeProp { }
 interface ITest
 {
     bool SomeProp { get; set; }
-}");
+}", index: 1);
         }
 
         [WorkItem(539468, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539468")]
@@ -1533,8 +1532,7 @@ bool ITest.SomeProp { }
 interface ITest
 {
     bool SomeProp { get; }
-}",
-index: 1);
+}");
         }
 
         [WorkItem(539468, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539468")]
@@ -7128,7 +7126,7 @@ public void Foo()
 
         [WorkItem(17621, "https://github.com/dotnet/roslyn/issues/17621")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
-        public async Task TestWithMatchingTypeName()
+        public async Task TestWithMatchingTypeName1()
         {
             await TestInRegularAndScript1Async(
 @"
@@ -7150,10 +7148,38 @@ public Foo(String foo)
         String = foo;
     }
 
-    public string String { get; private set; }
+    public string String { get; }
 }");
         }
 
+        [WorkItem(17621, "https://github.com/dotnet/roslyn/issues/17621")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
+        public async Task TestWithMatchingTypeName2()
+        {
+            await TestInRegularAndScript1Async(
+@"
+using System;
+
+public class Foo
+{
+    public Foo(String foo)
+    {
+        [|String|] = foo;
+    }
+}",
+@"using System;
+
+public class Foo
+{
+    public Foo(String foo)
+    {
+        String = foo;
+    }
+
+    public string String { get; private set; }
+}", index: 1);
+        }
+
         [WorkItem(18275, "https://github.com/dotnet/roslyn/issues/18275")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddImport)]
         public async Task TestContextualKeyword1()
@@ -7227,6 +7253,29 @@ public Class()
         _bar = 1;
         _foo = 0;
     }
+}");
+        }
+
+        [WorkItem(19239, "https://github.com/dotnet/roslyn/issues/19239")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
+        public async Task TestGenerateReadOnlyPropertyInConstructor()
+        {
+            await TestInRegularAndScriptAsync(
+@"class Class
+{
+    public Class()
+    {
+        [|Bar|] = 1;
+    }
+}",
+@"class Class
+{
+    public Class()
+    {
+        Bar = 1;
+    }
+
+    public int Bar { get; }
 }");
         }
     }
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
index 1aee2bf794011..f5348949eb81e 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
@@ -38,7 +38,6 @@ private partial class State
             public ITypeSymbol LocalType { get; private set; }
 
             public bool ReadOnlyFieldFirst { get; private set; }
-            public bool ReadOnlyPropertyFirst { get; private set; }
 
             public bool IsWrittenTo { get; private set; }
             public bool IsOnlyWrittenTo { get; private set; }
@@ -257,7 +256,6 @@ private bool TryInitializeSimpleName(
                 this.IsInMemberContext = this.SimpleNameOpt != this.SimpleNameOrMemberAccessExpressionOpt ||
                                          syntaxFacts.IsObjectInitializerNamedAssignmentIdentifier(this.SimpleNameOrMemberAccessExpressionOpt);
 
-                this.ReadOnlyPropertyFirst = DetermineReadOnlyFirst(document, SymbolKind.Property, cancellationToken);
                 this.ReadOnlyFieldFirst = DetermineReadOnlyFirst(document, SymbolKind.Field, cancellationToken);
 
                 return true;
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs
index 7391afaa4d749..d865a1f288a06 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs
@@ -108,22 +108,16 @@ private void AddPropertyCodeActions(
                 return;
             }
 
-            if (!state.ReadOnlyPropertyFirst)
-            {
-                GenerateWritableProperty(result, document, state);
-            }
+            var isOnlyReadAndIsInInterface = state.TypeToGenerateIn.TypeKind == TypeKind.Interface && !state.IsWrittenTo;
 
-            if (state.TypeToGenerateIn.TypeKind == TypeKind.Interface && !state.IsWrittenTo)
+            if (isOnlyReadAndIsInInterface || state.IsInConstructor)
             {
                 result.Add(new GenerateVariableCodeAction(
                     (TService)this, document, state, generateProperty: true,
                     isReadonly: true, isConstant: false, returnsByRef: state.IsInRefContext));
             }
 
-            if (state.ReadOnlyPropertyFirst)
-            {
-                GenerateWritableProperty(result, document, state);
-            }
+            GenerateWritableProperty(result, document, state);
         }
 
         private void GenerateWritableProperty(ArrayBuilder<CodeAction> result, SemanticDocument document, State state)

From 7e582ebd0331299c7cccdb2549cc68e46eb032f7 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Thu, 4 May 2017 23:43:28 -0700
Subject: [PATCH 039/284] VB side.

---
 .../GenerateVariable/GenerateVariableTests.vb | 93 ++++++++++++++++++-
 .../AbstractGenerateVariableService.State.cs  | 24 +++--
 .../AbstractGenerateVariableService.cs        |  4 +-
 3 files changed, 107 insertions(+), 14 deletions(-)

diff --git a/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateVariable/GenerateVariableTests.vb b/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateVariable/GenerateVariableTests.vb
index 89c40f3a13061..614172cce8c76 100644
--- a/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateVariable/GenerateVariableTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateVariable/GenerateVariableTests.vb
@@ -106,6 +106,29 @@ End Interface",
 End Module
 Interface IFoo
     ReadOnly Property Blah As String()
+End Interface")
+        End Function
+
+        <WorkItem(539694, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539694")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)>
+        Public Async Function TestGenerateReadWriteProperty() As Task
+            Await TestInRegularAndScriptAsync(
+"Module Program
+    Sub Main(args As String())
+        Dim i As IFoo
+        Main(i.[|Blah|])
+    End Sub
+End Module
+Interface IFoo
+End Interface",
+"Module Program
+    Sub Main(args As String())
+        Dim i As IFoo
+        Main(i.Blah)
+    End Sub
+End Module
+Interface IFoo
+    Property Blah As String()
 End Interface",
 index:=1)
         End Function
@@ -168,7 +191,7 @@ index:=1)
         End Function
 
         <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)>
-        Public Async Function TestGeneratePropertyOnInterface() As Threading.Tasks.Task
+        Public Async Function TestGeneratePropertyOnInterface1() As Threading.Tasks.Task
             Await TestInRegularAndScriptAsync(
 "Interface IFoo
 End Interface
@@ -179,7 +202,7 @@ Class C
     End Sub
 End Class",
 "Interface IFoo
-    Property Bar As Object
+    ReadOnly Property Bar As Object
 End Interface
 Class C
     Sub Main
@@ -189,6 +212,28 @@ Class C
 End Class")
         End Function
 
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)>
+        Public Async Function TestGeneratePropertyOnInterface2() As Threading.Tasks.Task
+            Await TestInRegularAndScriptAsync(
+"Interface IFoo
+End Interface
+Class C
+    Sub Main
+        Dim foo As IFoo
+        Dim b = foo.[|Bar|]
+    End Sub
+End Class",
+"Interface IFoo
+    Property Bar As Object
+End Interface
+Class C
+    Sub Main
+        Dim foo As IFoo
+        Dim b = foo.Bar
+    End Sub
+End Class", index:=1)
+        End Function
+
         <WorkItem(539796, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539796")>
         <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)>
         Public Async Function TestGeneratePropertyIntoModule() As Threading.Tasks.Task
@@ -2516,5 +2561,49 @@ End Class",
  End Sub
 End Class")
         End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)>
+        Public Async Function TestPreferReadOnlyIfAfterReadOnlyAssignment() As Task 
+            await TestInRegularAndScriptAsync(
+"class C
+    private readonly _foo as integer
+
+    public sub new()
+        _foo = 0
+        [|_bar|] = 1
+    end sub
+end class",
+"class C
+    private readonly _foo as integer
+    Private ReadOnly _bar As Integer
+
+    public sub new()
+        _foo = 0
+        _bar = 1
+    end sub
+end class")
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)>
+        Public Async Function TestPreferReadOnlyIfBeforeReadOnlyAssignment() As Task
+            Await TestInRegularAndScriptAsync(
+"class C
+    private readonly _foo as integer
+
+    public sub new()
+        [|_bar|] = 1
+        _foo = 0
+    end sub
+end class",
+"class C
+    private readonly _foo as integer
+    Private ReadOnly _bar As Integer
+
+    public sub new()
+        _bar = 1
+        _foo = 0
+    end sub
+end class")
+        End Function
     End Class
 End Namespace
\ No newline at end of file
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
index f5348949eb81e..1c6d4b677cfd6 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
@@ -37,7 +37,7 @@ private partial class State
             public ITypeSymbol TypeMemberType { get; private set; }
             public ITypeSymbol LocalType { get; private set; }
 
-            public bool ReadOnlyFieldFirst { get; private set; }
+            public bool OfferReadOnlyFieldFirst { get; private set; }
 
             public bool IsWrittenTo { get; private set; }
             public bool IsOnlyWrittenTo { get; private set; }
@@ -256,7 +256,7 @@ private bool TryInitializeSimpleName(
                 this.IsInMemberContext = this.SimpleNameOpt != this.SimpleNameOrMemberAccessExpressionOpt ||
                                          syntaxFacts.IsObjectInitializerNamedAssignmentIdentifier(this.SimpleNameOrMemberAccessExpressionOpt);
 
-                this.ReadOnlyFieldFirst = DetermineReadOnlyFirst(document, SymbolKind.Field, cancellationToken);
+                this.OfferReadOnlyFieldFirst = DetermineReadOnlyFirst(document, SymbolKind.Field, cancellationToken);
 
                 return true;
             }
@@ -269,16 +269,20 @@ private bool DetermineReadOnlyFirst(
 
                 if (syntaxFacts.IsLeftSideOfAssignment(simpleName))
                 {
-                    var assignment = simpleName.Parent;
-                    if (syntaxFacts.IsSimpleAssignmentStatement(assignment.Parent))
+                    var assignmentStatement = simpleName.Ancestors().FirstOrDefault(syntaxFacts.IsSimpleAssignmentStatement);
+                    if (assignmentStatement != null)
                     {
-                        var statement = assignment.Parent;
-                        var block = statement.Parent;
-                        var children = block.ChildNodesAndTokens();
+                        syntaxFacts.GetPartsOfAssignmentStatement(assignmentStatement, out var left, out var right);
 
-                        var statementindex = GetStatementindex(children, statement);
-                        return IsReadOnlyMemberAssignment(document, symbolKind, children, statementindex - 1, cancellationToken) ||
-                               IsReadOnlyMemberAssignment(document, symbolKind, children, statementindex + 1, cancellationToken);
+                        if (left == simpleName)
+                        {
+                            var block = assignmentStatement.Parent;
+                            var children = block.ChildNodesAndTokens();
+
+                            var statementindex = GetStatementindex(children, assignmentStatement);
+                            return IsReadOnlyMemberAssignment(document, symbolKind, children, statementindex - 1, cancellationToken) ||
+                                   IsReadOnlyMemberAssignment(document, symbolKind, children, statementindex + 1, cancellationToken);
+                        }
                     }
                 }
 
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs
index d865a1f288a06..cd25b2caf5e5f 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs
@@ -139,7 +139,7 @@ private void AddFieldCodeActions(ArrayBuilder<CodeAction> result, SemanticDocume
                 }
                 else
                 {
-                    if (!state.ReadOnlyFieldFirst)
+                    if (!state.OfferReadOnlyFieldFirst)
                     {
                         GenerateWriteableField(result, document, state);
                     }
@@ -153,7 +153,7 @@ private void AddFieldCodeActions(ArrayBuilder<CodeAction> result, SemanticDocume
                             isReadonly: true, isConstant: false, returnsByRef: false));
                     }
 
-                    if (state.ReadOnlyFieldFirst)
+                    if (state.OfferReadOnlyFieldFirst)
                     {
                         GenerateWriteableField(result, document, state);
                     }

From 875191bf7cee4f5f2584a19cb3237922dabd9714 Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam.harwell@microsoft.com>
Date: Fri, 5 May 2017 05:50:39 -0500
Subject: [PATCH 040/284] Use LookupSymbols and LookupNamespacesAndTypes to
 improve candidate speed and accuracy

---
 .../Extensions/ExpressionSyntaxExtensions.cs  | 40 +++++++++++--------
 1 file changed, 24 insertions(+), 16 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs
index 87a897aebe7b6..9e41dab000a75 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs
@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CodeStyle;
@@ -809,12 +810,23 @@ private static bool TryReduce(
                     return false;
                 }
 
-                // Get a syntax node that's not part of the tree to make sure we speculate on just the name.
-                var speculativeTree = memberAccess.Name.WithoutTrivia();
-                var symbolInfo = semanticModel.GetSpeculativeSymbolInfo(memberAccess.SpanStart, speculativeTree, SpeculativeBindingOption.BindAsExpression);
-                if (!IsReplacementCandidate(actualSymbol, symbolInfo))
+                var symbols = semanticModel.LookupSymbols(memberAccess.SpanStart, name: memberAccess.Name.Identifier.ValueText);
+                if (!IsReplacementCandidate(actualSymbol, symbols, ImmutableArray<ISymbol>.Empty))
                 {
-                    return false;
+                    if (symbols.IsEmpty)
+                    {
+                        // No need to lookup namespaces and types separately, because without a symbol of the sames name
+                        // in a local scope they would have already been found by LookupSymbols.
+                        return false;
+                    }
+
+                    // If we found symbols, but not the *right* symbols, also look up namespaces and types explicitly to
+                    // find candidates.
+                    var typeSymbols = semanticModel.LookupNamespacesAndTypes(memberAccess.SpanStart, name: memberAccess.Name.Identifier.ValueText);
+                    if (!IsReplacementCandidate(actualSymbol, symbols, typeSymbols))
+                    {
+                        return false;
+                    }
                 }
             }
 
@@ -832,29 +844,25 @@ private static bool TryReduce(
         }
 
         /// <summary>
-        /// Determines if <paramref name="speculativeSymbol"/> contains a superset of the symbols in
-        /// <paramref name="actualSymbol"/>.
+        /// Determines if <paramref name="speculativeSymbols"/> and <paramref name="speculativeNamespacesAndTypes"/>
+        /// together contain a superset of the symbols in <paramref name="actualSymbol"/>.
         /// </summary>
-        private static bool IsReplacementCandidate(SymbolInfo actualSymbol, SymbolInfo speculativeSymbol)
+        private static bool IsReplacementCandidate(SymbolInfo actualSymbol, ImmutableArray<ISymbol> speculativeSymbols, ImmutableArray<ISymbol> speculativeNamespacesAndTypes)
         {
-            if (!(speculativeSymbol.Symbol is null))
-            {
-                return Equals(actualSymbol.Symbol, speculativeSymbol.Symbol);
-            }
-
-            if (speculativeSymbol.CandidateSymbols.IsDefault)
+            if (speculativeSymbols.IsEmpty && speculativeNamespacesAndTypes.IsEmpty)
             {
                 return false;
             }
 
             if (!(actualSymbol.Symbol is null))
             {
-                return speculativeSymbol.CandidateSymbols.Contains(actualSymbol.Symbol);
+                return speculativeSymbols.Contains(actualSymbol.Symbol)
+                    || speculativeNamespacesAndTypes.Contains(actualSymbol.Symbol);
             }
 
             foreach (var symbol in actualSymbol.CandidateSymbols)
             {
-                if (!speculativeSymbol.CandidateSymbols.Contains(symbol))
+                if (!speculativeSymbols.Contains(symbol) && !speculativeNamespacesAndTypes.Contains(symbol))
                 {
                     return false;
                 }

From 94d573e47da0e8a093970f463da6406be1ae9959 Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam.harwell@microsoft.com>
Date: Fri, 5 May 2017 06:16:25 -0500
Subject: [PATCH 041/284] Avoid calling both LookupSymbols and
 LookupNamespacesAndTypes when we only need the latter

---
 .../Extensions/ExpressionSyntaxExtensions.cs  | 60 +++++++++++++------
 1 file changed, 43 insertions(+), 17 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs
index 9e41dab000a75..0fd7c7f739ce6 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs
@@ -805,28 +805,19 @@ private static bool TryReduce(
             if (!memberAccess.Expression.IsKind(SyntaxKind.ThisExpression, SyntaxKind.BaseExpression))
             {
                 var actualSymbol = semanticModel.GetSymbolInfo(memberAccess.Name, cancellationToken);
-                if (actualSymbol.GetAnySymbol() is null)
+                if (!TryGetReplacementCandidates(
+                    semanticModel,
+                    memberAccess,
+                    actualSymbol,
+                    out var speculativeSymbols,
+                    out var speculativeNamespacesAndTypes))
                 {
                     return false;
                 }
 
-                var symbols = semanticModel.LookupSymbols(memberAccess.SpanStart, name: memberAccess.Name.Identifier.ValueText);
-                if (!IsReplacementCandidate(actualSymbol, symbols, ImmutableArray<ISymbol>.Empty))
+                if (!IsReplacementCandidate(actualSymbol, speculativeSymbols, speculativeNamespacesAndTypes))
                 {
-                    if (symbols.IsEmpty)
-                    {
-                        // No need to lookup namespaces and types separately, because without a symbol of the sames name
-                        // in a local scope they would have already been found by LookupSymbols.
-                        return false;
-                    }
-
-                    // If we found symbols, but not the *right* symbols, also look up namespaces and types explicitly to
-                    // find candidates.
-                    var typeSymbols = semanticModel.LookupNamespacesAndTypes(memberAccess.SpanStart, name: memberAccess.Name.Identifier.ValueText);
-                    if (!IsReplacementCandidate(actualSymbol, symbols, typeSymbols))
-                    {
-                        return false;
-                    }
+                    return false;
                 }
             }
 
@@ -843,6 +834,41 @@ private static bool TryReduce(
             return memberAccess.CanReplaceWithReducedName(replacementNode, semanticModel, cancellationToken);
         }
 
+        private static bool TryGetReplacementCandidates(
+            SemanticModel semanticModel,
+            MemberAccessExpressionSyntax memberAccess,
+            SymbolInfo actualSymbol,
+            out ImmutableArray<ISymbol> speculativeSymbols,
+            out ImmutableArray<ISymbol> speculativeNamespacesAndTypes)
+        {
+            bool containsNamespaceOrTypeSymbol;
+            bool containsOtherSymbol;
+            if (!(actualSymbol.Symbol is null))
+            {
+                containsNamespaceOrTypeSymbol = actualSymbol.Symbol is INamespaceOrTypeSymbol;
+                containsOtherSymbol = !containsNamespaceOrTypeSymbol;
+            }
+            else if (!actualSymbol.CandidateSymbols.IsDefaultOrEmpty)
+            {
+                containsNamespaceOrTypeSymbol = actualSymbol.CandidateSymbols.Any(symbol => symbol is INamespaceOrTypeSymbol);
+                containsOtherSymbol = actualSymbol.CandidateSymbols.Any(symbol => !(symbol is INamespaceOrTypeSymbol));
+            }
+            else
+            {
+                speculativeSymbols = ImmutableArray<ISymbol>.Empty;
+                speculativeNamespacesAndTypes = ImmutableArray<ISymbol>.Empty;
+                return false;
+            }
+
+            speculativeSymbols = containsOtherSymbol
+                ? semanticModel.LookupSymbols(memberAccess.SpanStart, name: memberAccess.Name.Identifier.ValueText)
+                : ImmutableArray<ISymbol>.Empty;
+            speculativeNamespacesAndTypes = containsNamespaceOrTypeSymbol
+                ? semanticModel.LookupNamespacesAndTypes(memberAccess.SpanStart, name: memberAccess.Name.Identifier.ValueText)
+                : ImmutableArray<ISymbol>.Empty;
+            return true;
+        }
+
         /// <summary>
         /// Determines if <paramref name="speculativeSymbols"/> and <paramref name="speculativeNamespacesAndTypes"/>
         /// together contain a superset of the symbols in <paramref name="actualSymbol"/>.

From 36d55d1d20da6464f4106572da7223bf8f236cc2 Mon Sep 17 00:00:00 2001
From: Ravi Chande <rchande@microsoft.com>
Date: Fri, 5 May 2017 08:28:29 -0700
Subject: [PATCH 042/284] Revert "Merge pull request #10993 from
 rchande/quickinfosession"

This reverts commit 3ef5891043f89145b1e1c1a7de8c0e02acd15c6e, reversing
changes made to 923fcbf40f87c7c50ea09c8375556c293795874a.
---
 .../IntelliSense/QuickInfo/Controller.cs      | 24 +++++--------------
 .../IntelliSense/QuickInfo/Model.cs           |  2 ++
 ...InfoPresenter.QuickInfoPresenterSession.cs |  6 -----
 3 files changed, 8 insertions(+), 24 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/Controller.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/Controller.cs
index f230eeff3a5d6..d5808c101bfe9 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/Controller.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/Controller.cs
@@ -77,26 +77,14 @@ internal override void OnModelUpdated(Model modelOpt)
             }
             else
             {
+                var quickInfoItem = modelOpt.Item;
+
                 // We want the span to actually only go up to the caret.  So get the expected span
                 // and then update its end point accordingly.
-                ITrackingSpan trackingSpan;
-                QuickInfoItem item = null;
+                var triggerSpan = modelOpt.GetCurrentSpanInSnapshot(quickInfoItem.TextSpan, this.SubjectBuffer.CurrentSnapshot);
+                var trackingSpan = triggerSpan.CreateTrackingSpan(SpanTrackingMode.EdgeInclusive);
 
-                // Whether or not we have an item to show, we need to start the session.
-                // If the user Edit.QuickInfo's on a squiggle, they want to see the 
-                // error text even if there's no symbol quickinfo.
-                if (modelOpt.Item != null)
-                {
-                    item = modelOpt.Item;
-                    var triggerSpan = modelOpt.GetCurrentSpanInSnapshot(item.TextSpan, this.SubjectBuffer.CurrentSnapshot);
-                    trackingSpan = triggerSpan.CreateTrackingSpan(SpanTrackingMode.EdgeInclusive);
-                }
-                else
-                {
-                    var caret = this.TextView.GetCaretPoint(this.SubjectBuffer).Value;
-                    trackingSpan = caret.Snapshot.CreateTrackingSpan(caret.Position, 0, SpanTrackingMode.EdgeInclusive, TrackingFidelityMode.Forward);
-                }
-                sessionOpt.PresenterSession.PresentItem(trackingSpan, item, modelOpt.TrackMouse);
+                sessionOpt.PresenterSession.PresentItem(trackingSpan, quickInfoItem, modelOpt.TrackMouse);
             }
         }
 
@@ -170,7 +158,7 @@ private async Task<Model> ComputeModelInBackgroundAsync(
                         }
                     }
 
-                    return new Model(snapshot.Version, null, null, trackMouse);
+                    return null;
                 }
             }
             catch (Exception e) when (FatalError.ReportUnlessCanceled(e))
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/Model.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/Model.cs
index d137e532acf78..ba37c6ced2a6c 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/Model.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/Model.cs
@@ -20,6 +20,8 @@ public Model(
             IQuickInfoProvider provider,
             bool trackMouse)
         {
+            Contract.ThrowIfNull(item);
+
             this.TextVersion = textVersion;
             this.Item = item;
             this.Provider = provider;
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/Presentation/QuickInfoPresenter.QuickInfoPresenterSession.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/Presentation/QuickInfoPresenter.QuickInfoPresenterSession.cs
index d6caa46b94153..f31ab17118f3e 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/Presentation/QuickInfoPresenter.QuickInfoPresenterSession.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/Presentation/QuickInfoPresenter.QuickInfoPresenterSession.cs
@@ -100,12 +100,6 @@ private void OnEditorSessionDismissed()
 
             internal void AugmentQuickInfoSession(IList<object> quickInfoContent, out ITrackingSpan applicableToSpan)
             {
-                if (_item == null)
-                {
-                    applicableToSpan = null;
-                    return;
-                }
-
                 applicableToSpan = _triggerSpan;
                 quickInfoContent.Add(_item.Content.Create());
             }

From a4d168aef3637768ddf5b463a603ef019a260aa0 Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam.harwell@microsoft.com>
Date: Fri, 5 May 2017 10:42:58 -0500
Subject: [PATCH 043/284] Compare candidate symbols by their original
 definition

The bound symbols have instantiated generic types/methods, but the candidates
found through a lookup by name do not. We compare their original definitions
to treat these uninstantiated generics as true candidates for simplification.
---
 .../Extensions/ExpressionSyntaxExtensions.cs  | 34 +++++++++++++++++--
 .../Utilities/ImmutableArrayExtensions.cs     |  3 ++
 2 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs
index 0fd7c7f739ce6..95225e1765ef6 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs
@@ -882,13 +882,14 @@ private static bool IsReplacementCandidate(SymbolInfo actualSymbol, ImmutableArr
 
             if (!(actualSymbol.Symbol is null))
             {
-                return speculativeSymbols.Contains(actualSymbol.Symbol)
-                    || speculativeNamespacesAndTypes.Contains(actualSymbol.Symbol);
+                return speculativeSymbols.Contains(actualSymbol.Symbol, CandidateSymbolEqualityComparer.Instance)
+                    || speculativeNamespacesAndTypes.Contains(actualSymbol.Symbol, CandidateSymbolEqualityComparer.Instance);
             }
 
             foreach (var symbol in actualSymbol.CandidateSymbols)
             {
-                if (!speculativeSymbols.Contains(symbol) && !speculativeNamespacesAndTypes.Contains(symbol))
+                if (!speculativeSymbols.Contains(symbol, CandidateSymbolEqualityComparer.Instance)
+                    && !speculativeNamespacesAndTypes.Contains(symbol, CandidateSymbolEqualityComparer.Instance))
                 {
                     return false;
                 }
@@ -897,6 +898,33 @@ private static bool IsReplacementCandidate(SymbolInfo actualSymbol, ImmutableArr
             return true;
         }
 
+        /// <summary>
+        /// Compares symbols by their original definition.
+        /// </summary>
+        private sealed class CandidateSymbolEqualityComparer : IEqualityComparer<ISymbol>
+        {
+            public static CandidateSymbolEqualityComparer Instance { get; } = new CandidateSymbolEqualityComparer();
+
+            private CandidateSymbolEqualityComparer()
+            {
+            }
+
+            public bool Equals(ISymbol x, ISymbol y)
+            {
+                if (x is null || y is null)
+                {
+                    return x == y;
+                }
+
+                return x.OriginalDefinition.Equals(y.OriginalDefinition);
+            }
+
+            public int GetHashCode(ISymbol obj)
+            {
+                return obj?.OriginalDefinition.GetHashCode() ?? 0;
+            }
+        }
+
         private static SyntaxTriviaList GetLeadingTriviaForSimplifiedMemberAccess(this MemberAccessExpressionSyntax memberAccess)
         {
             // We want to include any user-typed trivia that may be present between the 'Expression', 'OperatorToken' and 'Identifier' of the MemberAccessExpression.
diff --git a/src/Workspaces/Core/Portable/Utilities/ImmutableArrayExtensions.cs b/src/Workspaces/Core/Portable/Utilities/ImmutableArrayExtensions.cs
index 58f3e2d24f359..1485111673fc0 100644
--- a/src/Workspaces/Core/Portable/Utilities/ImmutableArrayExtensions.cs
+++ b/src/Workspaces/Core/Portable/Utilities/ImmutableArrayExtensions.cs
@@ -8,6 +8,9 @@ namespace Roslyn.Utilities
 {
     internal static class ImmutableArrayExtensions
     {
+        internal static bool Contains<T>(this ImmutableArray<T> items, T item, IEqualityComparer<T> equalityComparer)
+            => items.IndexOf(item, 0, equalityComparer) >= 0;
+
         internal static ImmutableArray<T> ToImmutableArrayOrEmpty<T>(this T[] items)
         {
             if (items == null)

From 1d9b64a214cfaee648e5ab0c02f85cbbded6edad Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Fri, 5 May 2017 09:55:59 -0700
Subject: [PATCH 044/284] Fix one unit test and skip couple of unit tests due
 to the API changes. I have filed #19300 to track the skipped tests

---
 .../Diagnostics/OperationAnalyzerTests.cs        |  2 +-
 .../Diagnostics/OperationAnalyzerTests.vb        | 16 ++++++++++++----
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Semantic/Diagnostics/OperationAnalyzerTests.cs b/src/Compilers/CSharp/Test/Semantic/Diagnostics/OperationAnalyzerTests.cs
index 68664fd6013fe..794bfc28d8034 100644
--- a/src/Compilers/CSharp/Test/Semantic/Diagnostics/OperationAnalyzerTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Diagnostics/OperationAnalyzerTests.cs
@@ -835,7 +835,7 @@ public void M3()
                 );
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19300")]
         public void MemberInitializerCSharp()
         {
             const string source = @"
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Diagnostics/OperationAnalyzerTests.vb b/src/Compilers/VisualBasic/Test/Semantic/Diagnostics/OperationAnalyzerTests.vb
index 055d69d51c90e..4fa188e6ddbdd 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Diagnostics/OperationAnalyzerTests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Diagnostics/OperationAnalyzerTests.vb
@@ -794,7 +794,7 @@ End Class
                                            Diagnostic(NullArgumentTestAnalyzer.NullArgumentsDescriptor.Id, "Nothing").WithLocation(20, 26))
         End Sub
 
-        <Fact>
+        <Fact(Skip:="https://github.com/dotnet/roslyn/issues/19300")>
         Public Sub MemberInitializerVisualBasic()
             Dim source = <compilation>
                              <file name="c.vb">
@@ -877,9 +877,17 @@ End Class
             Dim comp = CompilationUtils.CreateCompilationWithMscorlibAndVBRuntime(source, parseOptions:=TestOptions.RegularWithIOperationFeature)
             comp.VerifyDiagnostics()
             comp.VerifyAnalyzerDiagnostics({New AssignmentTestAnalyzer}, Nothing, Nothing, False,
-                Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, "f1.Field = 0").WithLocation(22, 9),
-                Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, "f1.Prop1 = Nothing").WithLocation(23, 9),
-                Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, "f2.Field = True").WithLocation(26, 9))
+              Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, ".Prop2 = New Bar() With {.Field = True}").WithLocation(21, 32),
+              Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, ".Field = 10").WithLocation(14, 34),
+              Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, ".Prop1 = Nothing").WithLocation(15, 32),
+              Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, ".Field = 10").WithLocation(16, 32),
+              Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, ".Prop1 = Nothing").WithLocation(16, 45),
+              Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, ".Prop2 = New Bar() With {.Field = True}").WithLocation(17, 32),
+              Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, ".Field = True").WithLocation(17, 57),
+              Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, ".Field = True").WithLocation(21, 57),
+              Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, "f1.Field = 0").WithLocation(22, 9),
+              Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, "f1.Prop1 = Nothing").WithLocation(23, 9),
+              Diagnostic(AssignmentTestAnalyzer.DoNotUseMemberAssignmentDescriptor.Id, "f2.Field = True").WithLocation(26, 9))
         End Sub
 
         <Fact>

From a124f06493bafaede2440fc6344a5d058c9bbc55 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Fri, 5 May 2017 13:24:41 -0700
Subject: [PATCH 045/284] some loggings

---
 ...HostClientServiceFactory.SolutionChecksumUpdater.cs |  3 +++
 src/Workspaces/Remote/Core/Services/SolutionService.cs | 10 +++++++++-
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs b/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs
index 2a85108a87d22..1142557513758 100644
--- a/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs
@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.SolutionCrawler;
 using Microsoft.CodeAnalysis.Internal.Log;
+using System.Diagnostics;
 
 namespace Microsoft.VisualStudio.LanguageServices.Remote
 {
@@ -121,6 +122,8 @@ private async Task SynchronizePrimaryWorkspaceAsync(CancellationToken cancellati
                 {
                     var solution = _service.Workspace.CurrentSolution;
                     var checksum = await solution.State.GetChecksumAsync(cancellationToken).ConfigureAwait(false);
+                     
+                    Debug.WriteLine("**** Update Remote Primary Workspace");
 
                     await remoteHostClient.RunOnRemoteHostAsync(
                         WellKnownRemoteHostServices.RemoteHostService, solution,
diff --git a/src/Workspaces/Remote/Core/Services/SolutionService.cs b/src/Workspaces/Remote/Core/Services/SolutionService.cs
index e6a103347048b..3dfaf89731005 100644
--- a/src/Workspaces/Remote/Core/Services/SolutionService.cs
+++ b/src/Workspaces/Remote/Core/Services/SolutionService.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
+using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Options;
@@ -33,7 +34,8 @@ public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, Cancella
         {
             var currentSolution = GetAvailableSolution(solutionChecksum);
             if (currentSolution != null)
-            {
+            { 
+                Debug.WriteLine("**** Cache Hit outside of lock " + (currentSolution.Workspace is RemoteWorkspace).ToString());
                 return currentSolution;
             }
 
@@ -43,6 +45,7 @@ public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, Cancella
                 currentSolution = GetAvailableSolution(solutionChecksum);
                 if (currentSolution != null)
                 {
+                    Debug.WriteLine("**** Cache Hit inside of lock " + (currentSolution.Workspace is RemoteWorkspace).ToString());
                     return currentSolution;
                 }
 
@@ -61,6 +64,7 @@ public async Task UpdatePrimaryWorkspaceAsync(Checksum solutionChecksum, Cancell
             if (primarySolutionChecksum == solutionChecksum)
             {
                 // nothing changed
+                Debug.WriteLine("**** Primary workspace up to date");
                 return;
             }
 
@@ -78,12 +82,14 @@ private async Task<Solution> CreateSolution_NoLockAsync(Checksum solutionChecksu
             if (await updater.IsIncrementalUpdateAsync(solutionChecksum).ConfigureAwait(false))
             {
                 // solution has updated
+                Debug.WriteLine("**** Incremental solution update!");
                 return await updater.CreateSolutionAsync(solutionChecksum).ConfigureAwait(false);
             }
 
             // new solution. bulk sync all asset for the solution
             await _assetService.SynchronizeSolutionAssetsAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
 
+            Debug.WriteLine("**** Not same as primary workspace! new temporary workspace created!");
             var workspace = new TemporaryWorkspace(await updater.CreateSolutionInfoAsync(solutionChecksum).ConfigureAwait(false));
             return workspace.CurrentSolution;
         }
@@ -95,6 +101,7 @@ private async Task<Solution> UpdatePrimaryWorkspace_NoLockAsync(Checksum solutio
             if (await updater.IsIncrementalUpdateAsync(solutionChecksum).ConfigureAwait(false))
             {
                 // solution has updated
+                Debug.WriteLine("**** Primary worksace incremental update!");
                 s_primaryWorkspace.UpdateSolution(await updater.CreateSolutionAsync(solutionChecksum).ConfigureAwait(false));
 
                 return s_primaryWorkspace.CurrentSolution;
@@ -103,6 +110,7 @@ private async Task<Solution> UpdatePrimaryWorkspace_NoLockAsync(Checksum solutio
             // new solution. bulk sync all asset for the solution
             await _assetService.SynchronizeSolutionAssetsAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
 
+            Debug.WriteLine("**** New Primary workspace!");
             s_primaryWorkspace.ClearSolution();
             s_primaryWorkspace.AddSolution(await updater.CreateSolutionInfoAsync(solutionChecksum).ConfigureAwait(false));
 

From 5a6e108c55c1963c2260853069ffcd53b04b0b5a Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Fri, 5 May 2017 13:57:02 -0700
Subject: [PATCH 046/284] Fix analysis of IOperation descendants for
 BoundDelegateCreationExpression

The current IOperation API implementation of BoundDelegateCreationExpression has a bunch of issues and needs to be redesigned. This is tracked by #8897 and will be addressed post 15.3. Meanwhile, to unblock analyzers on code containing delegate creation expressions with lambda arguments, this bound node has been switched to OperationKind.None with override for Children property.

Fixes the first repro case provided in #8884
---
 .../CSharp/Portable/BoundTree/Expression.cs   | 34 ++-----
 ...tionTests_IParameterReferenceExpression.cs | 90 +++++++++++++++++++
 .../Portable/BoundTree/Expression.vb          | 37 ++------
 ...tionTests_IParameterReferenceExpression.vb | 79 ++++++++++++++++
 4 files changed, 181 insertions(+), 59 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index 605ada05830fa..097a7ed78ed93 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -414,44 +414,20 @@ public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, T
         }
     }
 
-    internal partial class BoundDelegateCreationExpression : IMethodBindingExpression
+    internal partial class BoundDelegateCreationExpression
     {
-        IOperation IMemberReferenceExpression.Instance
-        {
-            get
-            {
-                BoundMethodGroup methodGroup = this.Argument as BoundMethodGroup;
-                if (methodGroup != null)
-                {
-                    return methodGroup.InstanceOpt;
-                }
-
-                return null;
-            }
-        }
-
-        bool IMethodBindingExpression.IsVirtual =>
-            (object)this.MethodOpt != null &&
-            (this.MethodOpt.IsVirtual || this.MethodOpt.IsAbstract || this.MethodOpt.IsOverride) &&
-            !this.SuppressVirtualCalls;
-
-        ISymbol IMemberReferenceExpression.Member => this.MethodOpt;
-
-        IMethodSymbol IMethodBindingExpression.Method => this.MethodOpt;
-
-        protected override OperationKind ExpressionKind => OperationKind.MethodBindingExpression;
+        protected override OperationKind ExpressionKind => OperationKind.None;
 
-        // SyntaxNode for MethodBindingExpression is the argument of DelegateCreationExpression 
-        SyntaxNode IOperation.Syntax => this.Argument.Syntax;
+        protected override ImmutableArray<IOperation> Children => ImmutableArray.Create<IOperation>(this.Argument); 
 
         public override void Accept(OperationVisitor visitor)
         {
-            visitor.VisitMethodBindingExpression(this);
+            visitor.VisitNoneOperation(this);
         }
 
         public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, TResult> visitor, TArgument argument)
         {
-            return visitor.VisitMethodBindingExpression(this, argument);
+            return visitor.VisitNoneOperation(this, argument);
         }
     }
 
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.cs
index 509772a22f199..ed488198a123e 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.cs
@@ -191,6 +191,96 @@ public void M(int x, int y, int z)
             VerifyOperationTreeAndDiagnosticsForTest<ObjectCreationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
+        [Fact, WorkItem(8884, "https://github.com/dotnet/roslyn/issues/8884")]
+        public void ParameterReference_DelegateCreationExpressionWithLambdaArgument()
+        {
+            string source = @"
+using System;
+
+class Class
+{
+    // Used parameter methods
+    public void UsedParameterMethod1(Action a)
+    {
+        Action a2 = /*<bind>*/new Action(() =>
+        {
+            a();
+        })/*</bind>*/;
+    }
+}
+";
+            string expectedOperationTree = @"
+IOperation:  (OperationKind.None) (Syntax: 'new Action( ... })')
+  Children(1): ILambdaExpression (Signature: lambda expression) (OperationKind.LambdaExpression, Type: System.Action) (Syntax: '() => ... }')
+      IBlockStatement (2 statements) (OperationKind.BlockStatement) (Syntax: '{ ... }')
+        IExpressionStatement (OperationKind.ExpressionStatement) (Syntax: 'a();')
+          IInvocationExpression (virtual void System.Action.Invoke()) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'a()')
+            Instance Receiver: IParameterReferenceExpression: a (OperationKind.ParameterReferenceExpression, Type: System.Action) (Syntax: 'a')
+        IReturnStatement (OperationKind.ReturnStatement) (Syntax: '{ ... }')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<ObjectCreationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [Fact, WorkItem(8884, "https://github.com/dotnet/roslyn/issues/8884")]
+        public void ParameterReference_DelegateCreationExpressionWithMethodArgument()
+        {
+            string source = @"
+using System;
+
+class Class
+{
+    public delegate void Delegate(int x, int y);
+
+    public void Method(Delegate d)
+    {
+        var a = /*<bind>*/new Delegate(Method2)/*</bind>*/;
+    }
+
+    public void Method2(int x, int y)
+    {
+    }
+}
+";
+            string expectedOperationTree = @"
+IOperation:  (OperationKind.None) (Syntax: 'new Delegate(Method2)')
+  Children(1): IOperation:  (OperationKind.None) (Syntax: 'Method2')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<ObjectCreationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [Fact, WorkItem(8884, "https://github.com/dotnet/roslyn/issues/8884")]
+        public void ParameterReference_DelegateCreationExpressionWithInvalidArgument()
+        {
+            string source = @"
+using System;
+
+class Class
+{
+    public delegate void Delegate(int x, int y);
+
+    public void Method(int x)
+    {
+        var a = /*<bind>*/new Delegate(x)/*</bind>*/;
+    }
+}
+";
+            string expectedOperationTree = @"
+IInvalidExpression (OperationKind.InvalidExpression, Type: Class.Delegate, IsInvalid) (Syntax: 'new Delegate(x)')
+  Children(1): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+";
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS0149: Method name expected
+                //         var a = /*<bind>*/new Delegate(x)/*</bind>*/;
+                Diagnostic(ErrorCode.ERR_MethodNameExpected, "x").WithLocation(10, 40)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<ObjectCreationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
         [Fact, WorkItem(8884, "https://github.com/dotnet/roslyn/issues/8884")]
         public void ParameterReference_DynamicCollectionInitializer()
         {
diff --git a/src/Compilers/VisualBasic/Portable/BoundTree/Expression.vb b/src/Compilers/VisualBasic/Portable/BoundTree/Expression.vb
index 029f3a6f4c820..92ed00158a1f4 100644
--- a/src/Compilers/VisualBasic/Portable/BoundTree/Expression.vb
+++ b/src/Compilers/VisualBasic/Portable/BoundTree/Expression.vb
@@ -1500,46 +1500,23 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
     End Class
 
     Friend Partial Class BoundDelegateCreationExpression
-        Implements IMethodBindingExpression
 
-        Private ReadOnly Property IMemberReferenceExpression_Instance As IOperation Implements IMemberReferenceExpression.Instance
-            Get
-                If Me.Method.IsShared Then
-                    Return Nothing
-                Else
-                    Return Me.ReceiverOpt
-                End If
-            End Get
-        End Property
-
-        Private ReadOnly Property IMethodBindingExpression_IsVirtual As Boolean Implements IMethodBindingExpression.IsVirtual
-            Get
-                Return Me.Method IsNot Nothing AndAlso (Me.Method.IsOverridable OrElse Me.Method.IsOverrides OrElse Me.Method.IsMustOverride) AndAlso Not Me.SuppressVirtualCalls
-            End Get
-        End Property
-
-        Private ReadOnly Property IMemberReferenceExpression_Member As ISymbol Implements IMemberReferenceExpression.Member
-            Get
-                Return Me.Method
-            End Get
-        End Property
+        Protected Overrides Function ExpressionKind() As OperationKind
+            Return OperationKind.None
+        End Function
 
-        Private ReadOnly Property IMethodBindingExpression_Method As IMethodSymbol Implements IMethodBindingExpression.Method
+        Protected Overrides ReadOnly Property Children As ImmutableArray(Of IOperation)
             Get
-                Return Me.Method
+                Return ImmutableArray.Create(Of IOperation)(Me.ReceiverOpt)
             End Get
         End Property
 
-        Protected Overrides Function ExpressionKind() As OperationKind
-            Return OperationKind.MethodBindingExpression
-        End Function
-
         Public Overrides Sub Accept(visitor As OperationVisitor)
-            visitor.VisitMethodBindingExpression(Me)
+            visitor.VisitNoneOperation(Me)
         End Sub
 
         Public Overrides Function Accept(Of TArgument, TResult)(visitor As OperationVisitor(Of TArgument, TResult), argument As TArgument) As TResult
-            Return visitor.VisitMethodBindingExpression(Me, argument)
+            Return visitor.VisitNoneOperation(Me, argument)
         End Function
     End Class
 
diff --git a/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.vb b/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.vb
index 65581f7e4b429..511e6fa863f54 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.vb
@@ -272,6 +272,85 @@ IObjectCreationExpression (Constructor: Sub [Class]..ctor()) (OperationKind.Obje
             VerifyOperationTreeAndDiagnosticsForTest(Of ObjectCreationExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
         End Sub
 
+        <Fact, WorkItem(8884, "https://github.com/dotnet/roslyn/issues/8884")>
+        Public Sub ParameterReference_DelegateCreationExpressionWithLambdaArgument()
+            Dim source = <![CDATA[
+Option Strict Off
+Imports System
+
+Class Class1
+    Delegate Sub DelegateType()
+    Public Sub M(x As Object, y As EventArgs)
+        Dim eventHandler As New EventHandler(Function() x)'BIND:"New EventHandler(Function() x)"
+    End Sub
+End Class]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: System.EventHandler) (Syntax: 'New EventHa ... nction() x)')
+  ILambdaExpression (Signature: Function () As System.Object) (OperationKind.LambdaExpression, Type: null) (Syntax: 'Function() x')
+    IBlockStatement (3 statements, 1 locals) (OperationKind.BlockStatement) (Syntax: 'Function() x')
+      Locals: Local_1: <anonymous local> As System.Object
+      IReturnStatement (OperationKind.ReturnStatement) (Syntax: 'x')
+        IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Object) (Syntax: 'x')
+      ILabelStatement (Label: exit) (OperationKind.LabelStatement) (Syntax: 'Function() x')
+      IReturnStatement (OperationKind.ReturnStatement) (Syntax: 'Function() x')
+        ILocalReferenceExpression:  (OperationKind.LocalReferenceExpression, Type: System.Object) (Syntax: 'Function() x')
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of ObjectCreationExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <Fact, WorkItem(8884, "https://github.com/dotnet/roslyn/issues/8884")>
+        Public Sub ParameterReference_DelegateCreationExpressionWithMethodArgument()
+            Dim source = <![CDATA[
+Imports System
+
+Class Class1
+    Public Sub M(x As Object, y As EventArgs)
+        Dim eventHandler As New EventHandler(AddressOf Me.M)'BIND:"New EventHandler(AddressOf Me.M)"
+    End Sub
+End Class]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IConversionExpression (ConversionKind.Basic, Explicit) (OperationKind.ConversionExpression, Type: System.EventHandler) (Syntax: 'New EventHa ... essOf Me.M)')
+  IOperation:  (OperationKind.None) (Syntax: 'AddressOf Me.M')
+    Children(1): IInstanceReferenceExpression (InstanceReferenceKind.Explicit) (OperationKind.InstanceReferenceExpression, Type: Class1) (Syntax: 'Me')
+]]>.Value
+
+            Dim expectedDiagnostics = String.Empty
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of ObjectCreationExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
+        <Fact, WorkItem(8884, "https://github.com/dotnet/roslyn/issues/8884")>
+        Public Sub ParameterReference_DelegateCreationExpressionWithInvalidArgument()
+            Dim source = <![CDATA[
+Option Strict Off
+Imports System
+
+Class Class1
+    Delegate Sub DelegateType()
+    Public Sub M(x As Object, y As EventArgs)
+        Dim eventHandler As New EventHandler(x)'BIND:"New EventHandler(x)"
+    End Sub
+End Class]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IInvalidExpression (OperationKind.InvalidExpression, Type: System.EventHandler, IsInvalid) (Syntax: 'New EventHandler(x)')
+  Children(1): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Object) (Syntax: 'x')
+]]>.Value
+
+            Dim expectedDiagnostics = <![CDATA[
+BC32008: Delegate 'EventHandler' requires an 'AddressOf' expression or lambda expression as the only argument to its constructor.
+        Dim eventHandler As New EventHandler(x)'BIND:"New EventHandler(x)"
+                                            ~~~
+]]>.Value
+
+            VerifyOperationTreeAndDiagnosticsForTest(Of ObjectCreationExpressionSyntax)(source, expectedOperationTree, expectedDiagnostics)
+        End Sub
+
         <Fact, WorkItem(8884, "https://github.com/dotnet/roslyn/issues/8884")>
         Public Sub ParameterReference_NameOfExpression()
             Dim source = <![CDATA[

From bc9de278eef266820de7559db16bbad652f837c7 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Fri, 5 May 2017 14:03:47 -0700
Subject: [PATCH 047/284] added link to github issue to make option part of
 solution

---
 src/Workspaces/Core/Portable/Workspace/Solution/Document.cs | 2 +-
 .../Remote/Core/Diagnostics/DiagnosticComputer.cs           | 6 +++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
index 9536fd9e46507..58360061cf39c 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
@@ -472,7 +472,7 @@ internal Task<DocumentOptionSet> GetOptionsAsync(OptionSet globalOptionSet, Canc
             // TODO: we have this workaround since Solution.Options is not actually snapshot but just return Workspace.Options which violate snapshot model.
             //       this doesn't validate whether same optionset is given to invalidate the cache or not. this is not new since existing implementation
             //       also didn't check whether Workspace.Option is same as before or not. all wierd-ness come from the root cause of Solution.Options violating
-            //       snapshot model. once that is fixed, we can remove this workaround
+            //       snapshot model. once that is fixed, we can remove this workaround - https://github.com/dotnet/roslyn/issues/19284
             if (_cachedOptions == null)
             {
                 var newAsyncLazy = new AsyncLazy<DocumentOptionSet>(async c =>
diff --git a/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs b/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs
index a9bb623709a98..6bc968139429d 100644
--- a/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs
+++ b/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs
@@ -68,10 +68,14 @@ private async Task<DiagnosticAnalysisResultMap<string, DiagnosticAnalysisResultB
             // faster
             compilation = compilation.WithOptions(compilation.Options.WithConcurrentBuild(useConcurrent));
 
+            // We need this to fork soluton, otherwise, option is cached at document.
+            // all this can go away once we do this - https://github.com/dotnet/roslyn/issues/19284
+            var temporaryWorksapce = new TemporaryWorkspace(_project.Solution);
+
             // TODO: can we support analyzerExceptionFilter in remote host? 
             //       right now, host doesn't support watson, we might try to use new NonFatal watson API?
             var analyzerOptions = new CompilationWithAnalyzersOptions(
-                    options: new WorkspaceAnalyzerOptions(_project.AnalyzerOptions, MergeOptions(_project.Solution.Options, options), _project.Solution.Workspace),
+                    options: new WorkspaceAnalyzerOptions(_project.AnalyzerOptions, MergeOptions(_project.Solution.Options, options), temporaryWorksapce),
                     onAnalyzerException: OnAnalyzerException,
                     analyzerExceptionFilter: null,
                     concurrentAnalysis: useConcurrent,

From 4988c1cdc2d5244e69eb550dc1dd8b4ea9c82eab Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Fri, 5 May 2017 15:23:16 -0700
Subject: [PATCH 048/284] change to translate any exception to cancellation
 exception if cancellation is raised.

---
 .../Core/Next/Remote/JsonRpcClient.cs         | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/VisualStudio/Core/Next/Remote/JsonRpcClient.cs b/src/VisualStudio/Core/Next/Remote/JsonRpcClient.cs
index 42e1d7d427efd..64d5a62b7681a 100644
--- a/src/VisualStudio/Core/Next/Remote/JsonRpcClient.cs
+++ b/src/VisualStudio/Core/Next/Remote/JsonRpcClient.cs
@@ -42,12 +42,12 @@ public async Task InvokeAsync(string targetName, params object[] arguments)
             {
                 await _rpc.InvokeAsync(targetName, arguments).ConfigureAwait(false);
             }
-            catch (ObjectDisposedException)
+            catch 
             {
-                // object disposed exception can be thrown from StreamJsonRpc if JsonRpc is disposed in the middle of read/write.
-                // the way we added cancellation support to the JsonRpc which doesn't support cancellation natively
-                // can cause this exception to happen. newer version supports cancellation token natively, but
-                // we can't use it now, so we will catch object disposed exception and check cancellation token
+                // any exception can be thrown from StreamJsonRpc if JsonRpc is disposed in the middle of read/write.
+                // until we move to newly added cancellation support in JsonRpc, we will catch exception and translate to
+                // cancellation exception here. if any exception is thrown unrelated to cancellation, then we will rethrow
+                // the exception
                 _cancellationToken.ThrowIfCancellationRequested();
                 throw;
             }
@@ -61,12 +61,12 @@ public async Task<T> InvokeAsync<T>(string targetName, params object[] arguments
             {
                 return await _rpc.InvokeAsync<T>(targetName, arguments).ConfigureAwait(false);
             }
-            catch (ObjectDisposedException)
+            catch
             {
-                // object disposed exception can be thrown from StreamJsonRpc if JsonRpc is disposed in the middle of read/write.
-                // the way we added cancellation support to the JsonRpc which doesn't support cancellation natively
-                // can cause this exception to happen. newer version supports cancellation token natively, but
-                // we can't use it now, so we will catch object disposed exception and check cancellation token
+                // any exception can be thrown from StreamJsonRpc if JsonRpc is disposed in the middle of read/write.
+                // until we move to newly added cancellation support in JsonRpc, we will catch exception and translate to
+                // cancellation exception here. if any exception is thrown unrelated to cancellation, then we will rethrow
+                // the exception
                 _cancellationToken.ThrowIfCancellationRequested();
                 throw;
             }

From 3d11beecb074b6fe3c8f319564a8237d1cb5e5de Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Fri, 5 May 2017 15:24:51 -0700
Subject: [PATCH 049/284] made VS to crash explicitly when there is bad remote
 session consumer.

---
 .../Core/Portable/Execution/AssetStorages.cs        | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Execution/AssetStorages.cs b/src/Workspaces/Core/Portable/Execution/AssetStorages.cs
index c3a8b75e4dfde..82f107f8e1507 100644
--- a/src/Workspaces/Core/Portable/Execution/AssetStorages.cs
+++ b/src/Workspaces/Core/Portable/Execution/AssetStorages.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Threading;
@@ -156,13 +157,21 @@ public IReadOnlyDictionary<Checksum, RemotableData> GetRemotableData(PinnedRemot
         public void RegisterSnapshot(PinnedRemotableDataScope snapshot, AssetStorages.Storage storage)
         {
             // duplicates are not allowed, there can be multiple snapshots to same solution, so no ref counting.
-            Contract.ThrowIfFalse(_storages.TryAdd(snapshot, storage));
+            if (!_storages.TryAdd(snapshot, storage))
+            {
+                // this should make failure more explicit
+                FailFast.OnFatalException(new Exception("who is adding same snapshot?"));
+            }
         }
 
         public void UnregisterSnapshot(PinnedRemotableDataScope snapshot)
         {
             // calling it multiple times for same snapshot is not allowed.
-            Contract.ThrowIfFalse(_storages.TryRemove(snapshot, out var dummy));
+            if (!_storages.TryRemove(snapshot, out var dummy))
+            {
+                // this should make failure more explicit
+                FailFast.OnFatalException(new Exception("who is removing same snapshot?"));
+            }
         }
 
         private IEnumerable<Storage> GetStorages(PinnedRemotableDataScope scope)

From 5bdf617bb8a11241a37cea7ba3f4102d47c76d14 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Fri, 5 May 2017 17:21:19 -0700
Subject: [PATCH 050/284] send additional info when setting context for service
 call.

now, it includes flag whether given solution is for primary workspace or not.

this should benefit perf on initial solution load
---
 .../Core/Next/Remote/JsonRpcSession.cs        |  4 +-
 .../Services/SolutionServiceTests.cs          | 24 ++++++-
 .../Execution/PinnedRemotableDataScope.cs     |  2 +
 .../Remote/Core/Services/SolutionService.cs   | 70 +++++++++++--------
 .../ServiceHub/Services/SnapshotService.cs    |  4 +-
 .../Shared/ServiceHubServiceBase.cs           |  8 ++-
 6 files changed, 74 insertions(+), 38 deletions(-)

diff --git a/src/VisualStudio/Core/Next/Remote/JsonRpcSession.cs b/src/VisualStudio/Core/Next/Remote/JsonRpcSession.cs
index 95318f119232e..7d243c41766c5 100644
--- a/src/VisualStudio/Core/Next/Remote/JsonRpcSession.cs
+++ b/src/VisualStudio/Core/Next/Remote/JsonRpcSession.cs
@@ -89,10 +89,10 @@ private async Task InitializeAsync()
             // all roslyn remote service must based on ServiceHubServiceBase which implements Initialize method
             if (_snapshotClientOpt != null)
             {
-                await _snapshotClientOpt.InvokeAsync(WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, _currentSessionId, PinnedScopeOpt.SolutionChecksum).ConfigureAwait(false);
+                await _snapshotClientOpt.InvokeAsync(WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, _currentSessionId, PinnedScopeOpt.Primary, PinnedScopeOpt.SolutionChecksum).ConfigureAwait(false);
             }
 
-            await _serviceClient.InvokeAsync(WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, _currentSessionId, PinnedScopeOpt?.SolutionChecksum).ConfigureAwait(false);
+            await _serviceClient.InvokeAsync(WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, _currentSessionId, PinnedScopeOpt?.Primary, PinnedScopeOpt?.SolutionChecksum).ConfigureAwait(false);
         }
 
         public override Task InvokeAsync(string targetName, params object[] arguments)
diff --git a/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs b/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
index 3624063c1e2c8..0a59fa4789472 100644
--- a/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
+++ b/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
@@ -7,11 +7,9 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Remote;
 using Microsoft.CodeAnalysis.SolutionCrawler;
 using Microsoft.CodeAnalysis.Text;
-using Microsoft.VisualStudio.LanguageServices.Remote;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Roslyn.VisualStudio.Next.UnitTests.Mocks;
@@ -38,6 +36,28 @@ public async Task TestCreation()
             }
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
+        public async Task TestGetSolutionWithPrimaryFlag()
+        {
+            var code = @"class Test { void Method() { } }";
+
+            using (var workspace = TestWorkspace.CreateCSharp(code))
+            {
+                var solution = workspace.CurrentSolution;
+                var solutionChecksum = await solution.State.GetChecksumAsync(CancellationToken.None);
+
+                var service1 = await GetSolutionServiceAsync(solution);
+                var synched1 = await service1.GetSolutionAsync(solutionChecksum, CancellationToken.None);
+                Assert.Equal(solutionChecksum, await synched1.State.GetChecksumAsync(CancellationToken.None));
+                Assert.True(synched1.Workspace is TemporaryWorkspace);
+
+                var service2 = await GetSolutionServiceAsync(solution);
+                var synched2 = await service2.GetSolutionAsync(solutionChecksum, primary: true, cancellationToken: CancellationToken.None);
+                Assert.Equal(solutionChecksum, await synched2.State.GetChecksumAsync(CancellationToken.None));
+                Assert.True(synched2.Workspace is RemoteWorkspace);
+            }
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
         public async Task TestStrongNameProvider()
         {
diff --git a/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs b/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs
index be115ef2f7ffb..b318627aacac8 100644
--- a/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs
+++ b/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs
@@ -33,6 +33,8 @@ public PinnedRemotableDataScope(
             _storages.RegisterSnapshot(this, storage);
         }
 
+        public bool Primary => _storage.SolutionState.BranchId == Workspace.PrimaryBranchId;
+
         public Workspace Workspace => _storage.SolutionState.Workspace;
 
         /// <summary>
diff --git a/src/Workspaces/Remote/Core/Services/SolutionService.cs b/src/Workspaces/Remote/Core/Services/SolutionService.cs
index 3dfaf89731005..efc54e2731825 100644
--- a/src/Workspaces/Remote/Core/Services/SolutionService.cs
+++ b/src/Workspaces/Remote/Core/Services/SolutionService.cs
@@ -4,7 +4,6 @@
 using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Options;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Remote
@@ -30,12 +29,24 @@ public SolutionService(AssetService assetService)
             _assetService = assetService;
         }
 
-        public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
+        public Task<Solution> GetSolutionAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
+        {
+            return GetSolutionAsync(solutionChecksum, primary: false, cancellationToken: cancellationToken);
+        }
+
+        /// <summary>
+        /// This should be only consumed by engine, not by user.
+        /// </summary>
+        public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, bool primary, CancellationToken cancellationToken)
         {
             var currentSolution = GetAvailableSolution(solutionChecksum);
             if (currentSolution != null)
-            { 
-                Debug.WriteLine("**** Cache Hit outside of lock " + (currentSolution.Workspace is RemoteWorkspace).ToString());
+            {
+                if (!(currentSolution.Workspace is RemoteWorkspace))
+                {
+                    Debug.WriteLine("**** Cache Hit outside of lock false");
+                }
+
                 return currentSolution;
             }
 
@@ -45,17 +56,24 @@ public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, Cancella
                 currentSolution = GetAvailableSolution(solutionChecksum);
                 if (currentSolution != null)
                 {
-                    Debug.WriteLine("**** Cache Hit inside of lock " + (currentSolution.Workspace is RemoteWorkspace).ToString());
+                    if (!(currentSolution.Workspace is RemoteWorkspace))
+                    {
+                        Debug.WriteLine("**** Cache Hit outside of lock false");
+                    }
+
                     return currentSolution;
                 }
 
-                var solution = await CreateSolution_NoLockAsync(solutionChecksum, s_primaryWorkspace.CurrentSolution, cancellationToken).ConfigureAwait(false);
+                var solution = await CreateSolution_NoLockAsync(solutionChecksum, primary, s_primaryWorkspace.CurrentSolution, cancellationToken).ConfigureAwait(false);
                 s_lastSolution = Tuple.Create(solutionChecksum, solution);
 
                 return solution;
             }
         }
 
+        /// <summary>
+        /// This should be only consumed by engine, not by user.
+        /// </summary>
         public async Task UpdatePrimaryWorkspaceAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
         {
             var currentSolution = s_primaryWorkspace.CurrentSolution;
@@ -70,18 +88,26 @@ public async Task UpdatePrimaryWorkspaceAsync(Checksum solutionChecksum, Cancell
 
             using (await s_gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
             {
-                var solution = await UpdatePrimaryWorkspace_NoLockAsync(solutionChecksum, currentSolution, cancellationToken).ConfigureAwait(false);
+                var primary = true;
+                var solution = await CreateSolution_NoLockAsync(solutionChecksum, primary, currentSolution, cancellationToken).ConfigureAwait(false);
                 s_primarySolution = Tuple.Create(solutionChecksum, solution);
             }
         }
 
-        private async Task<Solution> CreateSolution_NoLockAsync(Checksum solutionChecksum, Solution baseSolution, CancellationToken cancellationToken)
+        private async Task<Solution> CreateSolution_NoLockAsync(Checksum solutionChecksum, bool primary, Solution baseSolution, CancellationToken cancellationToken)
         {
             var updater = new SolutionCreator(_assetService, baseSolution, cancellationToken);
 
             if (await updater.IsIncrementalUpdateAsync(solutionChecksum).ConfigureAwait(false))
             {
                 // solution has updated
+                if (primary)
+                {
+                    Debug.WriteLine("**** Primary worksace incremental update!");
+                    s_primaryWorkspace.UpdateSolution(await updater.CreateSolutionAsync(solutionChecksum).ConfigureAwait(false));
+                    return s_primaryWorkspace.CurrentSolution;
+                }
+
                 Debug.WriteLine("**** Incremental solution update!");
                 return await updater.CreateSolutionAsync(solutionChecksum).ConfigureAwait(false);
             }
@@ -89,32 +115,18 @@ private async Task<Solution> CreateSolution_NoLockAsync(Checksum solutionChecksu
             // new solution. bulk sync all asset for the solution
             await _assetService.SynchronizeSolutionAssetsAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
 
-            Debug.WriteLine("**** Not same as primary workspace! new temporary workspace created!");
-            var workspace = new TemporaryWorkspace(await updater.CreateSolutionInfoAsync(solutionChecksum).ConfigureAwait(false));
-            return workspace.CurrentSolution;
-        }
-
-        private async Task<Solution> UpdatePrimaryWorkspace_NoLockAsync(Checksum solutionChecksum, Solution baseSolution, CancellationToken cancellationToken)
-        {
-            var updater = new SolutionCreator(_assetService, baseSolution, cancellationToken);
-
-            if (await updater.IsIncrementalUpdateAsync(solutionChecksum).ConfigureAwait(false))
+            if (primary)
             {
-                // solution has updated
-                Debug.WriteLine("**** Primary worksace incremental update!");
-                s_primaryWorkspace.UpdateSolution(await updater.CreateSolutionAsync(solutionChecksum).ConfigureAwait(false));
+                Debug.WriteLine("**** New Primary workspace!");
+                s_primaryWorkspace.ClearSolution();
+                s_primaryWorkspace.AddSolution(await updater.CreateSolutionInfoAsync(solutionChecksum).ConfigureAwait(false));
 
                 return s_primaryWorkspace.CurrentSolution;
             }
 
-            // new solution. bulk sync all asset for the solution
-            await _assetService.SynchronizeSolutionAssetsAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
-
-            Debug.WriteLine("**** New Primary workspace!");
-            s_primaryWorkspace.ClearSolution();
-            s_primaryWorkspace.AddSolution(await updater.CreateSolutionInfoAsync(solutionChecksum).ConfigureAwait(false));
-
-            return s_primaryWorkspace.CurrentSolution;
+            Debug.WriteLine("**** Not same as primary workspace! new temporary workspace created!");
+            var workspace = new TemporaryWorkspace(await updater.CreateSolutionInfoAsync(solutionChecksum).ConfigureAwait(false));
+            return workspace.CurrentSolution;
         }
 
         private static Solution GetAvailableSolution(Checksum solutionChecksum)
diff --git a/src/Workspaces/Remote/ServiceHub/Services/SnapshotService.cs b/src/Workspaces/Remote/ServiceHub/Services/SnapshotService.cs
index 0312f42226972..698bcb1569d61 100644
--- a/src/Workspaces/Remote/ServiceHub/Services/SnapshotService.cs
+++ b/src/Workspaces/Remote/ServiceHub/Services/SnapshotService.cs
@@ -27,9 +27,9 @@ public SnapshotService(Stream stream, IServiceProvider serviceProvider) :
             Rpc.StartListening();
         }
 
-        public override void Initialize(int sessionId, byte[] solutionChecksum)
+        public override void Initialize(int sessionId, bool primary, Checksum solutionChecksum)
         {
-            base.Initialize(sessionId, solutionChecksum);
+            base.Initialize(sessionId, primary, solutionChecksum);
 
             lock (_gate)
             {
diff --git a/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs b/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs
index 84549a8cfd7d1..051a27624a059 100644
--- a/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs
+++ b/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs
@@ -28,6 +28,7 @@ internal abstract class ServiceHubServiceBase : IDisposable
         protected readonly CancellationToken CancellationToken;
 
         private int _sessionId;
+        private bool _primary;
         private Checksum _solutionChecksumOpt;
         private RoslynServices _lazyRoslynServices;
 
@@ -90,7 +91,7 @@ protected RoslynServices RoslynServices
         protected Task<Solution> GetSolutionAsync()
         {
             Contract.ThrowIfNull(_solutionChecksumOpt);
-            return RoslynServices.SolutionService.GetSolutionAsync(_solutionChecksumOpt, CancellationToken);
+            return RoslynServices.SolutionService.GetSolutionAsync(_solutionChecksumOpt, _primary, CancellationToken);
         }
 
         protected virtual void Dispose(bool disposing)
@@ -103,14 +104,15 @@ protected void LogError(string message)
             Log(TraceEventType.Error, message);
         }
 
-        public virtual void Initialize(int sessionId, byte[] solutionChecksum)
+        public virtual void Initialize(int sessionId, bool primary, Checksum solutionChecksum)
         {
             // set session related information
             _sessionId = sessionId;
+            _primary = primary;
 
             if (solutionChecksum != null)
             {
-                _solutionChecksumOpt = new Checksum(solutionChecksum);
+                _solutionChecksumOpt = solutionChecksum;
             }
         }
 

From a260bc69f22cb020f463a3ff50bcd37278220e32 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Fri, 5 May 2017 17:50:20 -0700
Subject: [PATCH 051/284] removed loggings

---
 .../Remote/Core/Services/SolutionService.cs      | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/src/Workspaces/Remote/Core/Services/SolutionService.cs b/src/Workspaces/Remote/Core/Services/SolutionService.cs
index efc54e2731825..c9dd90db2359d 100644
--- a/src/Workspaces/Remote/Core/Services/SolutionService.cs
+++ b/src/Workspaces/Remote/Core/Services/SolutionService.cs
@@ -42,11 +42,6 @@ public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, bool pri
             var currentSolution = GetAvailableSolution(solutionChecksum);
             if (currentSolution != null)
             {
-                if (!(currentSolution.Workspace is RemoteWorkspace))
-                {
-                    Debug.WriteLine("**** Cache Hit outside of lock false");
-                }
-
                 return currentSolution;
             }
 
@@ -56,11 +51,6 @@ public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, bool pri
                 currentSolution = GetAvailableSolution(solutionChecksum);
                 if (currentSolution != null)
                 {
-                    if (!(currentSolution.Workspace is RemoteWorkspace))
-                    {
-                        Debug.WriteLine("**** Cache Hit outside of lock false");
-                    }
-
                     return currentSolution;
                 }
 
@@ -81,8 +71,6 @@ public async Task UpdatePrimaryWorkspaceAsync(Checksum solutionChecksum, Cancell
             var primarySolutionChecksum = await currentSolution.State.GetChecksumAsync(cancellationToken).ConfigureAwait(false);
             if (primarySolutionChecksum == solutionChecksum)
             {
-                // nothing changed
-                Debug.WriteLine("**** Primary workspace up to date");
                 return;
             }
 
@@ -103,12 +91,10 @@ private async Task<Solution> CreateSolution_NoLockAsync(Checksum solutionChecksu
                 // solution has updated
                 if (primary)
                 {
-                    Debug.WriteLine("**** Primary worksace incremental update!");
                     s_primaryWorkspace.UpdateSolution(await updater.CreateSolutionAsync(solutionChecksum).ConfigureAwait(false));
                     return s_primaryWorkspace.CurrentSolution;
                 }
 
-                Debug.WriteLine("**** Incremental solution update!");
                 return await updater.CreateSolutionAsync(solutionChecksum).ConfigureAwait(false);
             }
 
@@ -117,14 +103,12 @@ private async Task<Solution> CreateSolution_NoLockAsync(Checksum solutionChecksu
 
             if (primary)
             {
-                Debug.WriteLine("**** New Primary workspace!");
                 s_primaryWorkspace.ClearSolution();
                 s_primaryWorkspace.AddSolution(await updater.CreateSolutionInfoAsync(solutionChecksum).ConfigureAwait(false));
 
                 return s_primaryWorkspace.CurrentSolution;
             }
 
-            Debug.WriteLine("**** Not same as primary workspace! new temporary workspace created!");
             var workspace = new TemporaryWorkspace(await updater.CreateSolutionInfoAsync(solutionChecksum).ConfigureAwait(false));
             return workspace.CurrentSolution;
         }

From 36c013bca3c99b7b05ad6bf51ccf9c1abd5f4b46 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Fri, 5 May 2017 18:07:41 -0700
Subject: [PATCH 052/284] removed logging

---
 .../RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs   | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs b/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs
index 1142557513758..3071ba2917d1b 100644
--- a/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs
@@ -122,8 +122,6 @@ private async Task SynchronizePrimaryWorkspaceAsync(CancellationToken cancellati
                 {
                     var solution = _service.Workspace.CurrentSolution;
                     var checksum = await solution.State.GetChecksumAsync(cancellationToken).ConfigureAwait(false);
-                     
-                    Debug.WriteLine("**** Update Remote Primary Workspace");
 
                     await remoteHostClient.RunOnRemoteHostAsync(
                         WellKnownRemoteHostServices.RemoteHostService, solution,

From 763af90ee6088bf4e3529907c694f26aa3b0ce4a Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 7 May 2017 14:29:20 -0700
Subject: [PATCH 053/284] Place fields/properties based on surrounding
 assignments.

---
 .../GenerateVariable/GenerateVariableTests.cs | 64 ++++++++++++++++-
 ...tractGenerateVariableService.CodeAction.cs | 70 +++++++++----------
 .../AbstractGenerateVariableService.State.cs  | 47 ++++++++++---
 3 files changed, 132 insertions(+), 49 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
index 3825d90a66a7b..194f645264609 100644
--- a/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
+++ b/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
@@ -7245,8 +7245,8 @@ public Class()
 }",
 @"class Class
 {
-    private readonly int _foo;
     private readonly int _bar;
+    private readonly int _foo;
 
     public Class()
     {
@@ -7276,6 +7276,68 @@ public Class()
     }
 
     public int Bar { get; }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
+        public async Task TestPlaceFieldBasedOnSurroundingStatements()
+        {
+            await TestInRegularAndScriptAsync(
+@"class Class
+{
+    private int _foo;
+    private int _quux;
+
+    public Class()
+    {
+        _foo = 0;
+        [|_bar|] = 1;
+        _quux = 2;
+    }
+}",
+@"class Class
+{
+    private int _foo;
+    private int _bar;
+    private int _quux;
+
+    public Class()
+    {
+        _foo = 0;
+        _bar = 1;
+        _quux = 2;
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
+        public async Task TestPlacePropertyBasedOnSurroundingStatements()
+        {
+            await TestInRegularAndScriptAsync(
+@"class Class
+{
+    public int Foo { get; }
+    public int Quuz { get; }
+
+    public Class()
+    {
+        Foo = 0;
+        [|Bar|] = 1;
+        Quux = 2;
+    }
+}",
+@"class Class
+{
+    public int Foo { get; }
+    public int Bar { get; }
+    public int Quuz { get; }
+
+    public Class()
+    {
+        Foo = 0;
+        Bar = 1;
+        Quux = 2;
+    }
 }");
         }
     }
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs
index 22ddd456bf16a..17530d1326892 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs
@@ -46,12 +46,18 @@ public GenerateVariableCodeAction(
                 _equivalenceKey = Title;
             }
 
-            protected override async Task<Document> GetChangedDocumentAsync(CancellationToken cancellationToken)
+            protected override Task<Document> GetChangedDocumentAsync(CancellationToken cancellationToken)
             {
+                var solution = _document.Project.Solution;
                 var syntaxTree = _document.SyntaxTree;
                 var generateUnsafe = _state.TypeMemberType.IsUnsafe() &&
                                      !_state.IsContainedInUnsafeType;
 
+                var otions = new CodeGenerationOptions(
+                    afterThisLocation: _state.AfterThisLocation,
+                    beforeThisLocation: _state.BeforeThisLocation,
+                    contextLocation: _state.IdentifierToken.GetLocation());
+
                 if (_generateProperty)
                 {
                     var getAccessor = CreateAccessor(DetermineMaximalAccessibility(_state), cancellationToken);
@@ -59,45 +65,35 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                         ? null 
                         : CreateAccessor(DetermineMinimalAccessibility(_state), cancellationToken);
 
-                    var result = await CodeGenerator.AddPropertyDeclarationAsync(
-                        _document.Project.Solution,
-                        _state.TypeToGenerateIn,
-                        CodeGenerationSymbolFactory.CreatePropertySymbol(
-                            attributes: default(ImmutableArray<AttributeData>),
-                            accessibility: DetermineMaximalAccessibility(_state),
-                            modifiers: new DeclarationModifiers(isStatic: _state.IsStatic, isUnsafe: generateUnsafe),
-                            type: _state.TypeMemberType,
-                            returnsByRef: _returnsByRef,
-                            explicitInterfaceSymbol: null,
-                            name: _state.IdentifierToken.ValueText,
-                            isIndexer: _state.IsIndexer,
-                            parameters: _state.Parameters,
-                            getMethod: getAccessor,
-                            setMethod: setAccessor),
-                        new CodeGenerationOptions(contextLocation: _state.IdentifierToken.GetLocation()),
-                        cancellationToken: cancellationToken)
-                        .ConfigureAwait(false);
-
-                    return result;
+                    var propertySymbol = CodeGenerationSymbolFactory.CreatePropertySymbol(
+                        attributes: default(ImmutableArray<AttributeData>),
+                        accessibility: DetermineMaximalAccessibility(_state),
+                        modifiers: new DeclarationModifiers(isStatic: _state.IsStatic, isUnsafe: generateUnsafe),
+                        type: _state.TypeMemberType,
+                        returnsByRef: _returnsByRef,
+                        explicitInterfaceSymbol: null,
+                        name: _state.IdentifierToken.ValueText,
+                        isIndexer: _state.IsIndexer,
+                        parameters: _state.Parameters,
+                        getMethod: getAccessor,
+                        setMethod: setAccessor);
+
+                    return CodeGenerator.AddPropertyDeclarationAsync(
+                        solution, _state.TypeToGenerateIn, propertySymbol, otions, cancellationToken);
                 }
                 else
                 {
-                    var result = await CodeGenerator.AddFieldDeclarationAsync(
-                        _document.Project.Solution,
-                        _state.TypeToGenerateIn,
-                        CodeGenerationSymbolFactory.CreateFieldSymbol(
-                            attributes: default(ImmutableArray<AttributeData>),
-                            accessibility: DetermineMinimalAccessibility(_state),
-                            modifiers: _isConstant ?
-                                new DeclarationModifiers(isConst: true, isUnsafe: generateUnsafe) :
-                                new DeclarationModifiers(isStatic: _state.IsStatic, isReadOnly: _isReadonly, isUnsafe: generateUnsafe),
-                            type: _state.TypeMemberType,
-                            name: _state.IdentifierToken.ValueText),
-                        new CodeGenerationOptions(contextLocation: _state.IdentifierToken.GetLocation()),
-                        cancellationToken: cancellationToken)
-                        .ConfigureAwait(false);
-
-                    return result;
+                    var fieldSymbol = CodeGenerationSymbolFactory.CreateFieldSymbol(
+                        attributes: default(ImmutableArray<AttributeData>),
+                        accessibility: DetermineMinimalAccessibility(_state),
+                        modifiers: _isConstant
+                            ? new DeclarationModifiers(isConst: true, isUnsafe: generateUnsafe)
+                            : new DeclarationModifiers(isStatic: _state.IsStatic, isReadOnly: _isReadonly, isUnsafe: generateUnsafe),
+                        type: _state.TypeMemberType,
+                        name: _state.IdentifierToken.ValueText);
+
+                    return CodeGenerator.AddFieldDeclarationAsync(
+                        solution, _state.TypeToGenerateIn, fieldSymbol, otions, cancellationToken);
                 }
             }
 
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
index 1c6d4b677cfd6..563127fbd0a6a 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
@@ -50,6 +50,9 @@ private partial class State
             public bool IsInExecutableBlock { get; private set; }
             public bool IsInConditionalAccessExpression { get; private set; }
 
+            public Location AfterThisLocation { get; private set; }
+            public Location BeforeThisLocation { get; private set; }
+
             public static async Task<State> GenerateAsync(
                 TService service,
                 SemanticDocument document,
@@ -256,14 +259,23 @@ private bool TryInitializeSimpleName(
                 this.IsInMemberContext = this.SimpleNameOpt != this.SimpleNameOrMemberAccessExpressionOpt ||
                                          syntaxFacts.IsObjectInitializerNamedAssignmentIdentifier(this.SimpleNameOrMemberAccessExpressionOpt);
 
-                this.OfferReadOnlyFieldFirst = DetermineReadOnlyFirst(document, SymbolKind.Field, cancellationToken);
+                CheckSurroundingContext(document, SymbolKind.Field, cancellationToken);
+                CheckSurroundingContext(document, SymbolKind.Property, cancellationToken);
 
                 return true;
             }
 
-            private bool DetermineReadOnlyFirst(
+            private void CheckSurroundingContext(
                 SemanticDocument document, SymbolKind symbolKind, CancellationToken cancellationToken)
             {
+                // See if we're being assigned to.  If so, look at the before/after statements
+                // to see if either is an assignment.  If so, we can use that to try to determine
+                // user patterns that can be used when generating the member.  For example,
+                // if the sibling assignment is to a readonly field, then we want to offer to 
+                // generate a readonly field vs a writable field.
+                //
+                // Also, because users often like to keep members/assignments in the same order
+                // we can pick a good place for the new member based on the surrounding assignments.
                 var syntaxFacts = document.Document.GetLanguageService<ISyntaxFactsService>();
                 var simpleName = this.SimpleNameOpt;
 
@@ -280,22 +292,30 @@ private bool DetermineReadOnlyFirst(
                             var children = block.ChildNodesAndTokens();
 
                             var statementindex = GetStatementindex(children, assignmentStatement);
-                            return IsReadOnlyMemberAssignment(document, symbolKind, children, statementindex - 1, cancellationToken) ||
-                                   IsReadOnlyMemberAssignment(document, symbolKind, children, statementindex + 1, cancellationToken);
+
+                            var previousAssignedSymbol = TryGetAssignedSymbol(document, symbolKind, children, statementindex - 1, cancellationToken);
+                            var nextAssignedSymbol = TryGetAssignedSymbol(document, symbolKind, children, statementindex + 1, cancellationToken);
+
+                            if (symbolKind == SymbolKind.Field)
+                            {
+                                this.OfferReadOnlyFieldFirst = IsReadOnly(previousAssignedSymbol) ||
+                                                               IsReadOnly(nextAssignedSymbol);
+                            }
+
+                            this.AfterThisLocation = this.AfterThisLocation ?? previousAssignedSymbol?.Locations.FirstOrDefault();
+                            this.BeforeThisLocation = this.BeforeThisLocation ?? nextAssignedSymbol?.Locations.FirstOrDefault();
                         }
                     }
                 }
-
-                return false;
             }
 
-            private bool IsReadOnlyMemberAssignment(
-                SemanticDocument document, SymbolKind symbolKind, 
+            private ISymbol TryGetAssignedSymbol(
+                SemanticDocument document, SymbolKind symbolKind,
                 ChildSyntaxList children, int index,
                 CancellationToken cancellationToken)
             {
                 var syntaxFacts = document.Document.GetLanguageService<ISyntaxFactsService>();
-                if (index >=  0 && index < children.Count)
+                if (index >= 0 && index < children.Count)
                 {
                     var sibling = children[index];
                     if (sibling.IsNode)
@@ -310,17 +330,22 @@ private bool IsReadOnlyMemberAssignment(
                             if (symbol?.Kind == symbolKind &&
                                 symbol.ContainingType.Equals(this.ContainingType))
                             {
-                                return IsReadOnly(symbol);
+                                return symbol;
                             }
                         }
                     }
                 }
 
-                return false;
+                return null;
             }
 
             private bool IsReadOnly(ISymbol symbol)
             {
+                if (symbol == null)
+                {
+                    return false;
+                }
+
                 switch (symbol)
                 {
                     case IFieldSymbol field: return field.IsReadOnly;

From 4e94fcddd57cdcfb70be8ebbaa004cdce065bac9 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 7 May 2017 14:37:08 -0700
Subject: [PATCH 054/284] Add VB tests.

---
 .../GenerateVariable/GenerateVariableTests.vb | 54 ++++++++++++++++++-
 1 file changed, 53 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateVariable/GenerateVariableTests.vb b/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateVariable/GenerateVariableTests.vb
index 614172cce8c76..f7e55ce25e732 100644
--- a/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateVariable/GenerateVariableTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateVariable/GenerateVariableTests.vb
@@ -2596,13 +2596,65 @@ end class")
     end sub
 end class",
 "class C
-    private readonly _foo as integer
     Private ReadOnly _bar As Integer
+    private readonly _foo as integer
 
     public sub new()
         _bar = 1
         _foo = 0
     end sub
+end class")
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)>
+        Public Async Function TestPlaceFieldBasedOnSurroundingStatements() As Task
+            await TestInRegularAndScriptAsync(
+"class Class
+    private _foo as integer
+    private _quux as integer
+
+    public sub new()
+        _foo = 0
+        [|_bar|] = 1
+        _quux = 2
+    end sub
+end class",
+"class Class
+    private _foo as integer
+    Private _bar As Integer
+    private _quux as integer
+
+    public sub new()
+        _foo = 0
+        _bar = 1
+        _quux = 2
+    end sub
+end class")
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)>
+        Public Async Function TestPlacePropertyBasedOnSurroundingStatements() As Task
+            Await TestInRegularAndScriptAsync(
+"class Class
+    public readonly property Foo as integer
+    public readonly property Quux as integer
+
+    public sub new()
+        Foo = 0
+        [|Bar|] = 1
+        Quux = 2
+    end sub
+end class",
+"class Class
+    public readonly property Foo as integer
+    Public ReadOnly Property Bar As Integer
+    public readonly property Quux as integer
+
+    public sub new()
+        Foo = 0
+        Bar = 1
+        Quux = 2
+    end sub
 end class")
         End Function
     End Class

From 72df26012c8c7cd18d142d1450c5aca0e80c9c47 Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Mon, 8 May 2017 14:29:00 -0700
Subject: [PATCH 055/284] Skip a bunch of failing tests due to the API change
 and fix an existing test to account for the change

---
 .../Test/Semantic/Diagnostics/OperationAnalyzerTests.cs      | 5 ++---
 .../Test/Semantic/Diagnostics/OperationAnalyzerTests.vb      | 4 ++--
 .../QualifyMemberAccess/QualifyMemberAccessTests.cs          | 2 +-
 3 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Semantic/Diagnostics/OperationAnalyzerTests.cs b/src/Compilers/CSharp/Test/Semantic/Diagnostics/OperationAnalyzerTests.cs
index 68664fd6013fe..b4d4881fd1443 100644
--- a/src/Compilers/CSharp/Test/Semantic/Diagnostics/OperationAnalyzerTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Diagnostics/OperationAnalyzerTests.cs
@@ -1121,7 +1121,7 @@ public override void M1()
                 );
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18839")]
         public void EventAndMethodReferencesCSharp()
         {
             const string source = @"
@@ -1440,8 +1440,7 @@ public void OnMumble(System.EventArgs args)
                 Diagnostic(LambdaTestAnalyzer.LambdaExpressionDescriptor.Id, "input => input++").WithLocation(9, 31),
                 Diagnostic(LambdaTestAnalyzer.LambdaExpressionDescriptor.Id, "input => { input++; input++; if (input > 0) return true; return false; }").WithLocation(10, 32),
                 Diagnostic(LambdaTestAnalyzer.TooManyStatementsInLambdaExpressionDescriptor.Id, "input => { input++; input++; if (input > 0) return true; return false; }").WithLocation(10, 32),
-                // Bug: missing a Lambda expression in delegate creation https://github.com/dotnet/roslyn/issues/8347
-                //Diagnostic(LambdaTestAnalyzer.LambdaExpressionDescriptor.Id, "(s, e) => { }").WithLocation(22, 42),
+                Diagnostic(LambdaTestAnalyzer.LambdaExpressionDescriptor.Id, "(s, e) => { }").WithLocation(22, 42),
                 Diagnostic(LambdaTestAnalyzer.LambdaExpressionDescriptor.Id, "(s, e) => { int i = 0; i++; i++; i++; }").WithLocation(23, 19),
                 Diagnostic(LambdaTestAnalyzer.TooManyStatementsInLambdaExpressionDescriptor.Id, "(s, e) => { int i = 0; i++; i++; i++; }").WithLocation(23, 19));
         }
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Diagnostics/OperationAnalyzerTests.vb b/src/Compilers/VisualBasic/Test/Semantic/Diagnostics/OperationAnalyzerTests.vb
index 055d69d51c90e..94a2286990644 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Diagnostics/OperationAnalyzerTests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Diagnostics/OperationAnalyzerTests.vb
@@ -1138,7 +1138,7 @@ End Class
                Diagnostic(ExplicitVsImplicitInstanceAnalyzer.ImplicitInstanceDescriptor.Id, "M2").WithLocation(15, 9))
         End Sub
 
-        <Fact>
+        <Fact(Skip:="https://github.com/dotnet/roslyn/issues/18839")>
         Public Sub EventAndMethodReferencesVisualBasic()
             Dim source = <compilation>
                              <file name="c.vb">
@@ -1411,7 +1411,7 @@ End Class
         End Sub
 
         <WorkItem(8385, "https://github.com/dotnet/roslyn/issues/8385")>
-        <Fact>
+        <Fact(Skip:="https://github.com/dotnet/roslyn/issues/18839")>
         Public Sub StaticMemberReferenceVisualBasic()
             Dim source = <compilation>
                              <file name="c.vb">
diff --git a/src/EditorFeatures/CSharpTest/QualifyMemberAccess/QualifyMemberAccessTests.cs b/src/EditorFeatures/CSharpTest/QualifyMemberAccess/QualifyMemberAccessTests.cs
index 8af4b22df59c6..b430e2d6bc90e 100644
--- a/src/EditorFeatures/CSharpTest/QualifyMemberAccess/QualifyMemberAccessTests.cs
+++ b/src/EditorFeatures/CSharpTest/QualifyMemberAccess/QualifyMemberAccessTests.cs
@@ -978,7 +978,7 @@ void M()
         }
 
         [WorkItem(15325, "https://github.com/dotnet/roslyn/issues/15325")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsQualifyMemberAccess)]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18839"), Trait(Traits.Feature, Traits.Features.CodeActionsQualifyMemberAccess)]
         public async Task QualifyInstanceMethodInDelegateCreation()
         {
             await TestAsyncWithOption(

From 0a6697e319ea07ada7d0addfdd4db05b8707b195 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 8 May 2017 17:15:51 -0700
Subject: [PATCH 056/284] Handle this.<name> expressions.

---
 .../GenerateVariable/GenerateVariableTests.cs | 31 +++++++++++++++++++
 .../AbstractGenerateVariableService.State.cs  |  5 +--
 2 files changed, 34 insertions(+), 2 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
index 194f645264609..74f87d68407cf 100644
--- a/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
+++ b/src/EditorFeatures/CSharpTest/Diagnostics/GenerateVariable/GenerateVariableTests.cs
@@ -7310,6 +7310,37 @@ public Class()
 }");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
+        public async Task TestPlaceFieldBasedOnSurroundingStatements2()
+        {
+            await TestInRegularAndScriptAsync(
+@"class Class
+{
+    private int foo;
+    private int quux;
+
+    public Class()
+    {
+        this.foo = 0;
+        this.[|bar|] = 1;
+        this.quux = 2;
+    }
+}",
+@"class Class
+{
+    private int foo;
+    private int bar;
+    private int quux;
+
+    public Class()
+    {
+        this.foo = 0;
+        this.bar = 1;
+        this.quux = 2;
+    }
+}");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateVariable)]
         public async Task TestPlacePropertyBasedOnSurroundingStatements()
         {
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
index 563127fbd0a6a..0009ba02bf2eb 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
@@ -277,14 +277,15 @@ private void CheckSurroundingContext(
                 // Also, because users often like to keep members/assignments in the same order
                 // we can pick a good place for the new member based on the surrounding assignments.
                 var syntaxFacts = document.Document.GetLanguageService<ISyntaxFactsService>();
-                var simpleName = this.SimpleNameOpt;
+                var simpleName = this.SimpleNameOrMemberAccessExpressionOpt;
 
                 if (syntaxFacts.IsLeftSideOfAssignment(simpleName))
                 {
                     var assignmentStatement = simpleName.Ancestors().FirstOrDefault(syntaxFacts.IsSimpleAssignmentStatement);
                     if (assignmentStatement != null)
                     {
-                        syntaxFacts.GetPartsOfAssignmentStatement(assignmentStatement, out var left, out var right);
+                        syntaxFacts.GetPartsOfAssignmentStatement(
+                            assignmentStatement, out var left, out var right);
 
                         if (left == simpleName)
                         {

From a015d76f7dc0fb048571da1cc998a5ce7bea42a6 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 8 May 2017 17:17:34 -0700
Subject: [PATCH 057/284] Simplify code.

---
 .../AbstractGenerateVariableService.State.cs  | 37 +++----------------
 1 file changed, 6 insertions(+), 31 deletions(-)

diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
index 0009ba02bf2eb..9339a8f4b1f30 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs
@@ -292,15 +292,15 @@ private void CheckSurroundingContext(
                             var block = assignmentStatement.Parent;
                             var children = block.ChildNodesAndTokens();
 
-                            var statementindex = GetStatementindex(children, assignmentStatement);
+                            var statementindex = GetStatementIndex(children, assignmentStatement);
 
                             var previousAssignedSymbol = TryGetAssignedSymbol(document, symbolKind, children, statementindex - 1, cancellationToken);
                             var nextAssignedSymbol = TryGetAssignedSymbol(document, symbolKind, children, statementindex + 1, cancellationToken);
 
                             if (symbolKind == SymbolKind.Field)
                             {
-                                this.OfferReadOnlyFieldFirst = IsReadOnly(previousAssignedSymbol) ||
-                                                               IsReadOnly(nextAssignedSymbol);
+                                this.OfferReadOnlyFieldFirst = FieldIsReadOnly(previousAssignedSymbol) ||
+                                                               FieldIsReadOnly(nextAssignedSymbol);
                             }
 
                             this.AfterThisLocation = this.AfterThisLocation ?? previousAssignedSymbol?.Locations.FirstOrDefault();
@@ -340,35 +340,10 @@ private ISymbol TryGetAssignedSymbol(
                 return null;
             }
 
-            private bool IsReadOnly(ISymbol symbol)
-            {
-                if (symbol == null)
-                {
-                    return false;
-                }
-
-                switch (symbol)
-                {
-                    case IFieldSymbol field: return field.IsReadOnly;
-                    case IPropertySymbol property:
-                        if (property.SetMethod == null)
-                        {
-                            return true;
-                        }
-
-                        if (property.ContainingType.GetMembers().OfType<IFieldSymbol>().Any(
-                                f => property.SetMethod.Equals(f.AssociatedSymbol)))
-                        {
-                            return true;
-                        }
-
-                        return false;
-                }
-
-                throw ExceptionUtilities.Unreachable;
-            }
+            private bool FieldIsReadOnly(ISymbol symbol)
+                => symbol is IFieldSymbol field && field.IsReadOnly;
 
-            private int GetStatementindex(ChildSyntaxList children, SyntaxNode statement)
+            private int GetStatementIndex(ChildSyntaxList children, SyntaxNode statement)
             {
                 var index = 0;
                 foreach (var child in children)

From 8aa521fea4de5ed4792854e32b81c9bc1c44de11 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 8 May 2017 17:54:23 -0700
Subject: [PATCH 058/284] Do not even attempt to create indices for non-C#/VB
 projects.

---
 .../SymbolTreeInfoIncrementalAnalyzerProvider.cs          | 8 ++++++--
 .../SyntaxTreeInfoIncrementalAnalyzerProvider.cs          | 6 ++++++
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs b/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
index 9f730f3180c94..6b961a156ffdf 100644
--- a/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
+++ b/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
@@ -4,7 +4,6 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Composition;
-using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -13,7 +12,6 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.NavigateTo;
-using Microsoft.CodeAnalysis.Shared.Utilities;
 using Microsoft.CodeAnalysis.SolutionCrawler;
 using Roslyn.Utilities;
 
@@ -181,6 +179,12 @@ public override Task AnalyzeProjectAsync(Project project, bool semanticsChanged,
 
             private async Task UpdateSymbolTreeInfoAsync(Project project, CancellationToken cancellationToken)
             {
+                if (!project.SupportsCompilation)
+                {                    
+                    // Not a language we can produce indices for (i.e. TypeScript).  Bail immediately.
+                    return;
+                }
+
                 if (project.Solution.Workspace.Kind != "Test" &&
                     project.Solution.Workspace.Kind != WorkspaceKind.RemoteWorkspace &&
                     project.Solution.Workspace.Options.GetOption(NavigateToOptions.OutOfProcessAllowed))
diff --git a/src/Features/Core/Portable/IncrementalCaches/SyntaxTreeInfoIncrementalAnalyzerProvider.cs b/src/Features/Core/Portable/IncrementalCaches/SyntaxTreeInfoIncrementalAnalyzerProvider.cs
index 9f3f4dec0ba5a..d9e183360f303 100644
--- a/src/Features/Core/Portable/IncrementalCaches/SyntaxTreeInfoIncrementalAnalyzerProvider.cs
+++ b/src/Features/Core/Portable/IncrementalCaches/SyntaxTreeInfoIncrementalAnalyzerProvider.cs
@@ -21,6 +21,12 @@ private class IncrementalAnalyzer : IncrementalAnalyzerBase
         {
             public override Task AnalyzeSyntaxAsync(Document document, InvocationReasons reasons, CancellationToken cancellationToken)
             {
+                if (!document.SupportsSyntaxTree)
+                {
+                    // Not a language we can produce indices for (i.e. TypeScript).  Bail immediately.
+                    return SpecializedTasks.EmptyTask;
+                }
+
                 if (document.Project.Solution.Workspace.Kind != WorkspaceKind.RemoteWorkspace &&
                     document.Project.Solution.Workspace.Options.GetOption(SymbolFinderOptions.OutOfProcessAllowed))
                 {

From 435ee7dc08cbefb1c1b450ec0ba0901cd95b26a8 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Mon, 8 May 2017 18:05:28 -0700
Subject: [PATCH 059/284] Refactored IErrorReportingService to extract the info
 bar display logic into IInfoBarService

---
 src/EditorFeatures/Core/EditorFeatures.csproj |   1 +
 .../EditorLayerExtensionManager.cs            |   8 +-
 .../Workspaces/EditorErrorReportingService.cs |   4 +-
 .../Workspaces/EditorInfoBarService.cs        |  23 ++
 ...tServiceFactory.RemoteHostClientService.cs |   6 +-
 .../VirtualMemoryNotificationListener.cs      |   4 +-
 .../VisualStudioErrorReportingService.cs      | 186 +---------------
 ...isualStudioErrorReportingServiceFactory.cs |  13 +-
 .../Workspace/VisualStudioInfoBarService.cs   | 200 ++++++++++++++++++
 .../Core/Def/ServicesVisualStudio.csproj      |   1 +
 .../IErrorReportingService.cs                 |  36 +---
 .../ExtensionManager/IInfoBarService.cs       |  52 +++++
 .../Core/Portable/Log/FunctionId.cs           |   1 +
 .../Core/Portable/Workspaces.csproj           |   1 +
 14 files changed, 303 insertions(+), 233 deletions(-)
 create mode 100644 src/EditorFeatures/Core/Implementation/Workspaces/EditorInfoBarService.cs
 create mode 100644 src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioInfoBarService.cs
 create mode 100644 src/Workspaces/Core/Portable/ExtensionManager/IInfoBarService.cs

diff --git a/src/EditorFeatures/Core/EditorFeatures.csproj b/src/EditorFeatures/Core/EditorFeatures.csproj
index 3a5b371a27e54..521cb964a62df 100644
--- a/src/EditorFeatures/Core/EditorFeatures.csproj
+++ b/src/EditorFeatures/Core/EditorFeatures.csproj
@@ -168,6 +168,7 @@
     <Compile Include="Implementation\Structure\BlockTagState.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionSetComparer.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionsSource.cs" />
+    <Compile Include="Implementation\Workspaces\EditorInfoBarService.cs" />
     <Compile Include="SymbolSearch\IAddReferenceDatabaseWrapper.cs" />
     <Compile Include="SymbolSearch\IDatabaseFactoryService.cs" />
     <Compile Include="SymbolSearch\IDelayService.cs" />
diff --git a/src/EditorFeatures/Core/Implementation/EditorLayerExtensionManager.cs b/src/EditorFeatures/Core/Implementation/EditorLayerExtensionManager.cs
index 39a94d1e9b8df..019533afd41bf 100644
--- a/src/EditorFeatures/Core/Implementation/EditorLayerExtensionManager.cs
+++ b/src/EditorFeatures/Core/Implementation/EditorLayerExtensionManager.cs
@@ -70,10 +70,10 @@ public override void HandleException(object provider, Exception exception)
                         base.HandleException(provider, exception);
 
                         _errorReportingService?.ShowErrorInfoInActiveView(String.Format(WorkspacesResources._0_encountered_an_error_and_has_been_disabled,  provider.GetType().Name),
-                            new ErrorReportingUI(WorkspacesResources.Show_Stack_Trace, ErrorReportingUI.UIKind.HyperLink, () => ShowDetailedErrorInfo(exception), closeAfterAction: false),
-                            new ErrorReportingUI(WorkspacesResources.Enable, ErrorReportingUI.UIKind.Button, () => { EnableProvider(provider); LogEnableProvider(provider); }),
-                            new ErrorReportingUI(WorkspacesResources.Enable_and_ignore_future_errors, ErrorReportingUI.UIKind.Button, () => { EnableProvider(provider); LogEnableProvider(provider); }),
-                            new ErrorReportingUI(String.Empty, ErrorReportingUI.UIKind.Close, () => LogLeaveDisabled(provider)));
+                            new InfoBarUI(WorkspacesResources.Show_Stack_Trace, InfoBarUI.UIKind.HyperLink, () => ShowDetailedErrorInfo(exception), closeAfterAction: false),
+                            new InfoBarUI(WorkspacesResources.Enable, InfoBarUI.UIKind.Button, () => { EnableProvider(provider); LogEnableProvider(provider); }),
+                            new InfoBarUI(WorkspacesResources.Enable_and_ignore_future_errors, InfoBarUI.UIKind.Button, () => { EnableProvider(provider); LogEnableProvider(provider); }),
+                            new InfoBarUI(String.Empty, InfoBarUI.UIKind.Close, () => LogLeaveDisabled(provider)));
                     }
                     else
                     {
diff --git a/src/EditorFeatures/Core/Implementation/Workspaces/EditorErrorReportingService.cs b/src/EditorFeatures/Core/Implementation/Workspaces/EditorErrorReportingService.cs
index fee9ec725e34a..c460c94a5c42d 100644
--- a/src/EditorFeatures/Core/Implementation/Workspaces/EditorErrorReportingService.cs
+++ b/src/EditorFeatures/Core/Implementation/Workspaces/EditorErrorReportingService.cs
@@ -13,12 +13,12 @@ public void ShowDetailedErrorInfo(Exception exception)
             Logger.Log(FunctionId.Extension_Exception, exception.StackTrace);
         }
 
-        public void ShowErrorInfoInActiveView(string message, params ErrorReportingUI[] items)
+        public void ShowErrorInfoInActiveView(string message, params InfoBarUI[] items)
         {
             ShowGlobalErrorInfo(message, items);
         }
 
-        public void ShowGlobalErrorInfo(string message, params ErrorReportingUI[] items)
+        public void ShowGlobalErrorInfo(string message, params InfoBarUI[] items)
         {
             Logger.Log(FunctionId.Extension_Exception, message);
         }
diff --git a/src/EditorFeatures/Core/Implementation/Workspaces/EditorInfoBarService.cs b/src/EditorFeatures/Core/Implementation/Workspaces/EditorInfoBarService.cs
new file mode 100644
index 0000000000000..5c98212530912
--- /dev/null
+++ b/src/EditorFeatures/Core/Implementation/Workspaces/EditorInfoBarService.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Extensions;
+using Microsoft.CodeAnalysis.Internal.Log;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.Workspaces
+{
+    internal class EditorInfoBarService : IInfoBarService
+    {
+        public void ShowInfoBarInActiveView(string message, params InfoBarUI[] items)
+        {
+            ShowInfoBarInGlobalView(message, items);
+        }
+
+        public void ShowInfoBarInGlobalView(string message, params InfoBarUI[] items)
+        {
+            Logger.Log(FunctionId.Extension_InfoBar, message);
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs b/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs
index be22435e65026..97eb651b02ccb 100644
--- a/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs
@@ -251,10 +251,10 @@ private void OnConnectionChanged(object sender, bool connected)
                     FatalError.ReportWithoutCrash(new Exception("Connection to remote host closed"));
 
                     // use info bar to show warning to users
-                    var infoBarUIs = new List<ErrorReportingUI>();
+                    var infoBarUIs = new List<InfoBarUI>();
 
                     infoBarUIs.Add(
-                        new ErrorReportingUI(ServicesVSResources.Learn_more, ErrorReportingUI.UIKind.HyperLink, () =>
+                        new InfoBarUI(ServicesVSResources.Learn_more, InfoBarUI.UIKind.HyperLink, () =>
                             BrowserHelper.StartBrowser(new Uri(OOPKilledMoreInfoLink)), closeAfterAction: false));
 
                     var allowRestarting = _workspace.Options.GetOption(RemoteHostOptions.RestartRemoteHostAllowed);
@@ -263,7 +263,7 @@ private void OnConnectionChanged(object sender, bool connected)
                         // this is hidden restart option. by default, user can't restart remote host that got killed
                         // by users
                         infoBarUIs.Add(
-                            new ErrorReportingUI("Restart external process", ErrorReportingUI.UIKind.Button, () =>
+                            new InfoBarUI("Restart external process", InfoBarUI.UIKind.Button, () =>
                             {
                                 // start off new remote host
                                 var unused = RequestNewRemoteHostAsync(CancellationToken.None);
diff --git a/src/VisualStudio/Core/Def/Implementation/VirtualMemoryNotificationListener.cs b/src/VisualStudio/Core/Def/Implementation/VirtualMemoryNotificationListener.cs
index 8c9e6897dd3a9..f188ccac7325f 100644
--- a/src/VisualStudio/Core/Def/Implementation/VirtualMemoryNotificationListener.cs
+++ b/src/VisualStudio/Core/Def/Implementation/VirtualMemoryNotificationListener.cs
@@ -95,9 +95,9 @@ public int OnBroadcastMessage(uint msg, IntPtr wParam, IntPtr lParam)
                                 _workspace.Options = _workspace.Options.WithChangedOption(RuntimeOptions.FullSolutionAnalysisInfoBarShown, true);
 
                                 _workspace.Services.GetService<IErrorReportingService>().ShowGlobalErrorInfo(ServicesVSResources.Visual_Studio_has_suspended_some_advanced_features_to_improve_performance,
-                                    new ErrorReportingUI(ServicesVSResources.Re_enable, ErrorReportingUI.UIKind.Button, () =>
+                                    new InfoBarUI(ServicesVSResources.Re_enable, InfoBarUI.UIKind.Button, () =>
                                         _workspace.Options = _workspace.Options.WithChangedOption(RuntimeOptions.FullSolutionAnalysis, true)),
-                                    new ErrorReportingUI(ServicesVSResources.Learn_more, ErrorReportingUI.UIKind.HyperLink, () =>
+                                    new InfoBarUI(ServicesVSResources.Learn_more, InfoBarUI.UIKind.HyperLink, () =>
                                         BrowserHelper.StartBrowser(new Uri(LowVMMoreInfoLink)), closeAfterAction: false));
                             }
                         }
diff --git a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingService.cs b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingService.cs
index ec8ce0d50562b..d443933dc82ba 100644
--- a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingService.cs
@@ -1,199 +1,27 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Extensions;
-using Microsoft.CodeAnalysis.Shared.TestHooks;
-using Microsoft.VisualStudio.Imaging;
-using Microsoft.VisualStudio.Shell;
-using Microsoft.VisualStudio.Shell.Interop;
-using Roslyn.Utilities;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation
 {
     internal partial class VisualStudioErrorReportingService : IErrorReportingService
     {
-        private readonly static InfoBarButton s_enableItem = new InfoBarButton(ServicesVSResources.Enable);
-        private readonly static InfoBarButton s_enableAndIgnoreItem = new InfoBarButton(ServicesVSResources.Enable_and_ignore_future_errors);
+        private readonly IInfoBarService _infoBarService;
 
-        private readonly IServiceProvider _serviceProvider;
-        private readonly IForegroundNotificationService _foregroundNotificationService;
-        private readonly IAsynchronousOperationListener _listener;
-
-        public VisualStudioErrorReportingService(
-            SVsServiceProvider serviceProvider, IForegroundNotificationService foregroundNotificationService, IAsynchronousOperationListener listener)
-        {
-            _serviceProvider = serviceProvider;
-            _foregroundNotificationService = foregroundNotificationService;
-            _listener = listener;
-        }
-
-        public void ShowErrorInfoInActiveView(string message, params ErrorReportingUI[] items)
-        {
-            ShowErrorInfo(activeView: true, message: message, items: items);
-        }
-
-        public void ShowGlobalErrorInfo(string message, params ErrorReportingUI[] items)
-        {
-            ShowErrorInfo(activeView: false, message: message, items: items);
-        }
-
-        public void ShowErrorInfo(bool activeView, string message, params ErrorReportingUI[] items)
-        {
-            // We can be called from any thread since errors can occur anywhere, however we can only construct and InfoBar from the UI thread.
-            _foregroundNotificationService.RegisterNotification(() =>
-            {
-                if (TryGetInfoBarData(activeView, out var infoBarHost))
-                {
-                    CreateInfoBar(infoBarHost, message, items);
-                }
-            }, _listener.BeginAsyncOperation("Show InfoBar"));
-        }
-
-        private bool TryGetInfoBarData(bool activeView, out IVsInfoBarHost infoBarHost)
-        {
-            infoBarHost = null;
-
-            if (activeView)
-            {
-                var monitorSelectionService = _serviceProvider.GetService(typeof(SVsShellMonitorSelection)) as IVsMonitorSelection;
-
-                // We want to get whichever window is currently in focus (including toolbars) as we could have had an exception thrown from the error list 
-                // or interactive window
-                if (monitorSelectionService == null ||
-                    ErrorHandler.Failed(monitorSelectionService.GetCurrentElementValue((uint)VSConstants.VSSELELEMID.SEID_WindowFrame, out var value)))
-                {
-                    return false;
-                }
-
-                var frame = value as IVsWindowFrame;
-                if (ErrorHandler.Failed(frame.GetProperty((int)__VSFPROPID7.VSFPROPID_InfoBarHost, out var activeViewInfoBar)))
-                {
-                    return false;
-                }
-
-                infoBarHost = activeViewInfoBar as IVsInfoBarHost;
-                return infoBarHost != null;
-            }
-
-            // global error info, show it on main window info bar
-            var shell = _serviceProvider.GetService(typeof(SVsShell)) as IVsShell;
-            if (shell == null ||
-                ErrorHandler.Failed(shell.GetProperty((int)__VSSPROPID7.VSSPROPID_MainWindowInfoBarHost, out var globalInfoBar)))
-            {
-                return false;
-            }
-
-            infoBarHost = globalInfoBar as IVsInfoBarHost;
-            return infoBarHost != null;
-        }
-
-        private void CreateInfoBar(IVsInfoBarHost infoBarHost, string message, ErrorReportingUI[] items)
+        public VisualStudioErrorReportingService(IInfoBarService infoBarService)
         {
-            var factory = _serviceProvider.GetService(typeof(SVsInfoBarUIFactory)) as IVsInfoBarUIFactory;
-            if (factory == null)
-            {
-                // no info bar factory, don't do anything
-                return;
-            }
-
-            var textSpans = new List<IVsInfoBarTextSpan>()
-            {
-                new InfoBarTextSpan(message)
-            };
-
-            // create action item list
-            var actionItems = new List<IVsInfoBarActionItem>();
-
-            foreach (var item in items)
-            {
-                switch (item.Kind)
-                {
-                    case ErrorReportingUI.UIKind.Button:
-                        actionItems.Add(new InfoBarButton(item.Title));
-                        break;
-                    case ErrorReportingUI.UIKind.HyperLink:
-                        actionItems.Add(new InfoBarHyperlink(item.Title));
-                        break;
-                    case ErrorReportingUI.UIKind.Close:
-                        break;
-                    default:
-                        throw ExceptionUtilities.UnexpectedValue(item.Kind);
-                }
-            }
-
-            var infoBarModel = new InfoBarModel(
-                textSpans,
-                actionItems.ToArray(),
-                KnownMonikers.StatusInformation,
-                isCloseButtonVisible: true);
-
-            if (!TryCreateInfoBarUI(factory, infoBarModel, out var infoBarUI))
-            {
-                return;
-            }
-
-            uint? infoBarCookie = null;
-            var eventSink = new InfoBarEvents(items, () =>
-            {
-                // run given onClose action if there is one.
-                items.FirstOrDefault(i => i.Kind == ErrorReportingUI.UIKind.Close).Action?.Invoke();
-
-                if (infoBarCookie.HasValue)
-                {
-                    infoBarUI.Unadvise(infoBarCookie.Value);
-                }
-            });
-
-            infoBarUI.Advise(eventSink, out var cookie);
-            infoBarCookie = cookie;
-
-            infoBarHost.AddInfoBar(infoBarUI);
+            _infoBarService = infoBarService;
         }
 
-        private class InfoBarEvents : IVsInfoBarUIEvents
+        public void ShowErrorInfoInActiveView(string message, params InfoBarUI[] items)
         {
-            private readonly ErrorReportingUI[] _items;
-            private readonly Action _onClose;
-
-            public InfoBarEvents(ErrorReportingUI[] items, Action onClose)
-            {
-                Contract.ThrowIfNull(onClose);
-
-                _items = items;
-                _onClose = onClose;
-            }
-
-            public void OnActionItemClicked(IVsInfoBarUIElement infoBarUIElement, IVsInfoBarActionItem actionItem)
-            {
-                var item = _items.FirstOrDefault(i => i.Title == actionItem.Text);
-                if (item.IsDefault)
-                {
-                    return;
-                }
-
-                item.Action?.Invoke();
-
-                if (!item.CloseAfterAction)
-                {
-                    return;
-                }
-
-                infoBarUIElement.Close();
-            }
-
-            public void OnClosed(IVsInfoBarUIElement infoBarUIElement)
-            {
-                _onClose();
-            }
+            _infoBarService.ShowInfoBarInActiveView(message, items);
         }
 
-        private static bool TryCreateInfoBarUI(IVsInfoBarUIFactory infoBarUIFactory, IVsInfoBar infoBar, out IVsInfoBarUIElement uiElement)
+        public void ShowGlobalErrorInfo(string message, params InfoBarUI[] items)
         {
-            uiElement = infoBarUIFactory.CreateInfoBar(infoBar);
-            return uiElement != null;
+            _infoBarService.ShowInfoBarInGlobalView(message, items);
         }
 
         public void ShowDetailedErrorInfo(Exception exception)
diff --git a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingServiceFactory.cs b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingServiceFactory.cs
index af1a7340912d3..4005022fc4ce1 100644
--- a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingServiceFactory.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingServiceFactory.cs
@@ -1,15 +1,9 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System;
-using System.Collections.Generic;
 using System.Composition;
-using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Extensions;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
-using Microsoft.CodeAnalysis.Shared.TestHooks;
-using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
-using Microsoft.VisualStudio.Shell;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation
 {
@@ -19,12 +13,9 @@ internal sealed class VisualStudioErrorReportingServiceFactory : IWorkspaceServi
         private readonly IErrorReportingService _singleton;
 
         [ImportingConstructor]
-        public VisualStudioErrorReportingServiceFactory(
-            SVsServiceProvider serviceProvider,
-            IForegroundNotificationService foregroundNotificationService,
-            [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners)
+        public VisualStudioErrorReportingServiceFactory(IInfoBarService infoBarService)
         {
-            _singleton = new VisualStudioErrorReportingService(serviceProvider, foregroundNotificationService, new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.InfoBar));
+            _singleton = new VisualStudioErrorReportingService(infoBarService);
         }
 
         public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
diff --git a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioInfoBarService.cs b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioInfoBarService.cs
new file mode 100644
index 0000000000000..eac76f3fe4172
--- /dev/null
+++ b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioInfoBarService.cs
@@ -0,0 +1,200 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Linq;
+using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.Extensions;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.VisualStudio.Imaging;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Shell.Interop;
+using Roslyn.Utilities;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation
+{
+    [Export(typeof(IInfoBarService))]
+    internal class VisualStudioInfoBarService : IInfoBarService
+    {
+        private readonly IServiceProvider _serviceProvider;
+        private readonly IForegroundNotificationService _foregroundNotificationService;
+        private readonly IAsynchronousOperationListener _listener;
+
+        [ImportingConstructor]
+        public VisualStudioInfoBarService([Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider,
+            IForegroundNotificationService foregroundNotificationService,
+            [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners)
+        {
+            _serviceProvider = serviceProvider;
+            _foregroundNotificationService = foregroundNotificationService;
+            _listener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.InfoBar);
+        }
+
+        public void ShowInfoBarInActiveView(string message, params InfoBarUI[] items)
+        {
+            ShowInfoBar(activeView: true, message: message, items: items);
+        }
+
+        public void ShowInfoBarInGlobalView(string message, params InfoBarUI[] items)
+        {
+            ShowInfoBar(activeView: false, message: message, items: items);
+        }
+
+        private void ShowInfoBar(bool activeView, string message, params InfoBarUI[] items)
+        {
+            // We can be called from any thread since errors can occur anywhere, however we can only construct and InfoBar from the UI thread.
+            _foregroundNotificationService.RegisterNotification(() =>
+            {
+                if (TryGetInfoBarData(activeView, out var infoBarHost))
+                {
+                    CreateInfoBar(infoBarHost, message, items);
+                }
+            }, _listener.BeginAsyncOperation("Show InfoBar"));
+        }
+
+        private bool TryGetInfoBarData(bool activeView, out IVsInfoBarHost infoBarHost)
+        {
+            infoBarHost = null;
+
+            if (activeView)
+            {
+                var monitorSelectionService = _serviceProvider.GetService(typeof(SVsShellMonitorSelection)) as IVsMonitorSelection;
+
+                // We want to get whichever window is currently in focus (including toolbars) as we could have had an exception thrown from the error list
+                // or interactive window
+                if (monitorSelectionService == null ||
+                    ErrorHandler.Failed(monitorSelectionService.GetCurrentElementValue((uint)VSConstants.VSSELELEMID.SEID_WindowFrame, out var value)))
+                {
+                    return false;
+                }
+
+                var frame = value as IVsWindowFrame;
+                if (ErrorHandler.Failed(frame.GetProperty((int)__VSFPROPID7.VSFPROPID_InfoBarHost, out var activeViewInfoBar)))
+                {
+                    return false;
+                }
+
+                infoBarHost = activeViewInfoBar as IVsInfoBarHost;
+                return infoBarHost != null;
+            }
+
+            // global error info, show it on main window info bar
+            var shell = _serviceProvider.GetService(typeof(SVsShell)) as IVsShell;
+            if (shell == null ||
+                ErrorHandler.Failed(shell.GetProperty((int)__VSSPROPID7.VSSPROPID_MainWindowInfoBarHost, out var globalInfoBar)))
+            {
+                return false;
+            }
+
+            infoBarHost = globalInfoBar as IVsInfoBarHost;
+            return infoBarHost != null;
+        }
+
+        private void CreateInfoBar(IVsInfoBarHost infoBarHost, string message, InfoBarUI[] items)
+        {
+            var factory = _serviceProvider.GetService(typeof(SVsInfoBarUIFactory)) as IVsInfoBarUIFactory;
+            if (factory == null)
+            {
+                // no info bar factory, don't do anything
+                return;
+            }
+
+            var textSpans = new List<IVsInfoBarTextSpan>()
+            {
+                new InfoBarTextSpan(message)
+            };
+
+            // create action item list
+            var actionItems = new List<IVsInfoBarActionItem>();
+
+            foreach (var item in items)
+            {
+                switch (item.Kind)
+                {
+                    case InfoBarUI.UIKind.Button:
+                        actionItems.Add(new InfoBarButton(item.Title));
+                        break;
+                    case InfoBarUI.UIKind.HyperLink:
+                        actionItems.Add(new InfoBarHyperlink(item.Title));
+                        break;
+                    case InfoBarUI.UIKind.Close:
+                        break;
+                    default:
+                        throw ExceptionUtilities.UnexpectedValue(item.Kind);
+                }
+            }
+
+            var infoBarModel = new InfoBarModel(
+                textSpans,
+                actionItems.ToArray(),
+                KnownMonikers.StatusInformation,
+                isCloseButtonVisible: true);
+
+            if (!TryCreateInfoBarUI(factory, infoBarModel, out var infoBarUI))
+            {
+                return;
+            }
+
+            uint? infoBarCookie = null;
+            var eventSink = new InfoBarEvents(items, () =>
+            {
+                // run given onClose action if there is one.
+                items.FirstOrDefault(i => i.Kind == InfoBarUI.UIKind.Close).Action?.Invoke();
+
+                if (infoBarCookie.HasValue)
+                {
+                    infoBarUI.Unadvise(infoBarCookie.Value);
+                }
+            });
+
+            infoBarUI.Advise(eventSink, out var cookie);
+            infoBarCookie = cookie;
+
+            infoBarHost.AddInfoBar(infoBarUI);
+        }
+
+        private class InfoBarEvents : IVsInfoBarUIEvents
+        {
+            private readonly InfoBarUI[] _items;
+            private readonly Action _onClose;
+
+            public InfoBarEvents(InfoBarUI[] items, Action onClose)
+            {
+                Contract.ThrowIfNull(onClose);
+
+                _items = items;
+                _onClose = onClose;
+            }
+
+            public void OnActionItemClicked(IVsInfoBarUIElement infoBarUIElement, IVsInfoBarActionItem actionItem)
+            {
+                var item = _items.FirstOrDefault(i => i.Title == actionItem.Text);
+                if (item.IsDefault)
+                {
+                    return;
+                }
+
+                item.Action?.Invoke();
+
+                if (!item.CloseAfterAction)
+                {
+                    return;
+                }
+
+                infoBarUIElement.Close();
+            }
+
+            public void OnClosed(IVsInfoBarUIElement infoBarUIElement)
+            {
+                _onClose();
+            }
+        }
+
+        private static bool TryCreateInfoBarUI(IVsInfoBarUIFactory infoBarUIFactory, IVsInfoBar infoBar, out IVsInfoBarUIElement uiElement)
+        {
+            uiElement = infoBarUIFactory.CreateInfoBar(infoBar);
+            return uiElement != null;
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj b/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
index 1809a21b16135..bad1214edf92c 100644
--- a/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
+++ b/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
@@ -168,6 +168,7 @@
     <Compile Include="Implementation\Workspace\VisualStudioErrorReportingService.ExceptionFormatting.cs" />
     <Compile Include="Implementation\Workspace\VisualStudioErrorReportingServiceFactory.cs" />
     <Compile Include="Implementation\Workspace\VisualStudioErrorReportingService.cs" />
+    <Compile Include="Implementation\Workspace\VisualStudioInfoBarService.cs" />
     <Compile Include="Implementation\Workspace\VisualStudioNavigationOptions.cs" />
     <Compile Include="Implementation\Workspace\VisualStudioNavigationOptionsProvider.cs" />
     <Compile Include="Implementation\Workspace\VisualStudioProjectCacheHostServiceFactory.cs" />
diff --git a/src/Workspaces/Core/Portable/ExtensionManager/IErrorReportingService.cs b/src/Workspaces/Core/Portable/ExtensionManager/IErrorReportingService.cs
index dfa4803ce26c2..4d5b1138c2bfa 100644
--- a/src/Workspaces/Core/Portable/ExtensionManager/IErrorReportingService.cs
+++ b/src/Workspaces/Core/Portable/ExtensionManager/IErrorReportingService.cs
@@ -2,7 +2,6 @@
 
 using System;
 using Microsoft.CodeAnalysis.Host;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Extensions
 {
@@ -10,46 +9,19 @@ internal interface IErrorReportingService : IWorkspaceService
     {
         /// <summary>
         /// Show error info in an active view.
-        /// 
+        ///
         /// Different host can have different definition on what active view means.
         /// </summary>
-        void ShowErrorInfoInActiveView(string message, params ErrorReportingUI[] items);
+        void ShowErrorInfoInActiveView(string message, params InfoBarUI[] items);
 
         /// <summary>
         /// Show global error info.
-        /// 
+        ///
         /// this kind error info should be something that affects whole roslyn such as
         /// background compilation is disabled due to memory issue and etc
         /// </summary>
-        void ShowGlobalErrorInfo(string message, params ErrorReportingUI[] items);
+        void ShowGlobalErrorInfo(string message, params InfoBarUI[] items);
 
         void ShowDetailedErrorInfo(Exception exception);
     }
-
-    internal struct ErrorReportingUI
-    {
-        public readonly string Title;
-        public readonly UIKind Kind;
-        public readonly Action Action;
-        public readonly bool CloseAfterAction;
-
-        public ErrorReportingUI(string title, UIKind kind, Action action, bool closeAfterAction = true)
-        {
-            Contract.ThrowIfNull(title);
-
-            Title = title;
-            Kind = kind;
-            Action = action;
-            CloseAfterAction = closeAfterAction;
-        }
-
-        public bool IsDefault => Title == null;
-
-        internal enum UIKind
-        {
-            Button,
-            HyperLink,
-            Close
-        }
-    }
 }
diff --git a/src/Workspaces/Core/Portable/ExtensionManager/IInfoBarService.cs b/src/Workspaces/Core/Portable/ExtensionManager/IInfoBarService.cs
new file mode 100644
index 0000000000000..789b0a53c87be
--- /dev/null
+++ b/src/Workspaces/Core/Portable/ExtensionManager/IInfoBarService.cs
@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using Microsoft.CodeAnalysis.Host;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.Extensions
+{
+    internal interface IInfoBarService : IWorkspaceService
+    {
+        /// <summary>
+        /// Show an info bar in the current active view.
+        ///
+        /// Different hosts can have different definitions on what active view means.
+        /// </summary>
+        void ShowInfoBarInActiveView(string message, params InfoBarUI[] items);
+
+        /// <summary>
+        /// Show global info bar
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="items"></param>
+        void ShowInfoBarInGlobalView(string message, params InfoBarUI[] items);
+    }
+
+    internal struct InfoBarUI
+    {
+        public readonly string Title;
+        public readonly UIKind Kind;
+        public readonly Action Action;
+        public readonly bool CloseAfterAction;
+
+        public InfoBarUI(string title, UIKind kind, Action action, bool closeAfterAction = true)
+        {
+            Contract.ThrowIfNull(title);
+
+            Title = title;
+            Kind = kind;
+            Action = action;
+            CloseAfterAction = closeAfterAction;
+        }
+
+        public bool IsDefault => Title == null;
+
+        internal enum UIKind
+        {
+            Button,
+            HyperLink,
+            Close
+        }
+    }
+}
diff --git a/src/Workspaces/Core/Portable/Log/FunctionId.cs b/src/Workspaces/Core/Portable/Log/FunctionId.cs
index 608bc297dbe10..fcce6868a6442 100644
--- a/src/Workspaces/Core/Portable/Log/FunctionId.cs
+++ b/src/Workspaces/Core/Portable/Log/FunctionId.cs
@@ -372,5 +372,6 @@ internal enum FunctionId
         CodeLens_GetFullyQualifiedName,
         RemoteHostClientService_Restarted,
         CodeAnalysisService_GetDesignerAttributesAsync,
+        Extension_InfoBar
     }
 }
diff --git a/src/Workspaces/Core/Portable/Workspaces.csproj b/src/Workspaces/Core/Portable/Workspaces.csproj
index 74ab71906e6bf..6ac048dde5611 100644
--- a/src/Workspaces/Core/Portable/Workspaces.csproj
+++ b/src/Workspaces/Core/Portable/Workspaces.csproj
@@ -207,6 +207,7 @@
     <Compile Include="..\..\..\Compilers\Core\Portable\Syntax\SyntaxTreeExtensions.cs">
       <Link>InternalUtilities\SyntaxTreeExtensions.cs</Link>
     </Compile>
+    <Compile Include="ExtensionManager\IInfoBarService.cs" />
   </ItemGroup>
   <ItemGroup>
     <InternalsVisibleTo Include="csi" />

From 98e2c2331c3745ca76ecbbe327664df441115f1a Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 8 May 2017 18:07:14 -0700
Subject: [PATCH 060/284] Revert "Merge pull request #18972 from
 CyrusNajmabadi/docHighlights2"

This reverts commit 8262112e63d0c92bfa421bcb49e54b6a791cabbd, reversing
changes made to 837ca2141fc63d42ea4f6310c07e58624f0ca48a.
---
 .../CSharp/CSharpEditorFeatures.csproj        |  2 +
 .../CSharpDocumentHighlightsService.cs        | 13 +++
 ...ighlightingAdditionalReferenceProvider.cs} | 26 +++--
 src/EditorFeatures/Core/EditorFeatures.csproj | 19 ++--
 ...viewReferenceHighlightingTaggerProvider.cs |  2 +-
 .../AbstractDocumentHighlightsService.cs      | 61 ++++--------
 .../DefinitionHighlightTag.cs                 |  2 +-
 .../DefinitionHighlightTagDefinition.cs       |  2 +-
 .../IDocumentHighlightsService.cs             |  3 +-
 ...HighlightingAdditionalReferenceProvider.cs | 14 +++
 ...htReferenceCommandHandler.StartComparer.cs |  2 +-
 ...ivateToHighlightReferenceCommandHandler.cs |  2 +-
 .../ReferenceHighlightTag.cs                  |  2 +-
 ...ReferenceHighlightingViewTaggerProvider.cs |  3 +-
 .../WrittenReferenceHighlightTag.cs           |  2 +-
 .../WrittenReferenceHighlightTagDefinition.cs |  2 +-
 .../AbstractReferenceHighlightingTests.vb     | 11 +--
 .../VisualBasic/BasicEditorFeatures.vbproj    |  2 +
 .../VisualBasicDocumentHighlightsService.vb   |  6 +-
 ...HighlightingAdditionalReferenceProvider.vb | 18 ++++
 .../CSharp/Portable/CSharpFeatures.csproj     |  1 -
 ...bstractDocumentHighlightsService_Remote.cs | 30 ------
 .../DocumentHighlightingOptions.cs            | 15 ---
 .../IRemoteDocumentHighlights.cs              | 94 -------------------
 src/Features/Core/Portable/Features.csproj    |  5 -
 .../VisualBasic/Portable/BasicFeatures.vbproj |  1 -
 ...bstractTableDataSourceFindUsagesContext.cs |  2 +-
 .../WithReferencesFindUsagesContext.cs        |  2 +-
 .../WithoutReferencesFindUsagesContext.cs     |  2 +-
 .../Entries/DocumentSpanEntry.cs              |  4 +-
 .../CSharp/CSharpReferenceHighlighting.cs     |  3 +-
 .../VisualBasic/BasicReferenceHighlighting.cs |  3 +-
 .../TestUtilities/WellKnownTagNames.cs        |  2 +-
 .../Remote/ServiceHub/ServiceHub.csproj       |  1 -
 .../CodeAnalysisService_DocumentHighlights.cs | 28 ------
 35 files changed, 117 insertions(+), 270 deletions(-)
 create mode 100644 src/EditorFeatures/CSharp/HighlightReferences/CSharpDocumentHighlightsService.cs
 rename src/{Features/CSharp/Portable/DocumentHighlighting/CSharpDocumentHighlightsService.cs => EditorFeatures/CSharp/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.cs} (70%)
 rename src/{Features/Core/Portable/DocumentHighlighting => EditorFeatures/Core/Implementation/ReferenceHighlighting}/AbstractDocumentHighlightsService.cs (82%)
 rename src/EditorFeatures/Core/{ReferenceHighlighting/Tags => Implementation/ReferenceHighlighting}/DefinitionHighlightTag.cs (88%)
 rename src/EditorFeatures/Core/{ReferenceHighlighting/Tags => Implementation/ReferenceHighlighting}/DefinitionHighlightTagDefinition.cs (92%)
 rename src/{Features/Core/Portable/DocumentHighlighting => EditorFeatures/Core/Implementation/ReferenceHighlighting}/IDocumentHighlightsService.cs (95%)
 create mode 100644 src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IReferenceHighlightingAdditionalReferenceProvider.cs
 rename src/EditorFeatures/Core/{ => Implementation}/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs (87%)
 rename src/EditorFeatures/Core/{ => Implementation}/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs (98%)
 rename src/EditorFeatures/Core/{ReferenceHighlighting/Tags => Implementation/ReferenceHighlighting}/ReferenceHighlightTag.cs (87%)
 rename src/EditorFeatures/Core/{ => Implementation}/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs (98%)
 rename src/EditorFeatures/Core/{ReferenceHighlighting/Tags => Implementation/ReferenceHighlighting}/WrittenReferenceHighlightTag.cs (88%)
 rename src/EditorFeatures/Core/{ReferenceHighlighting/Tags => Implementation/ReferenceHighlighting}/WrittenReferenceHighlightTagDefinition.cs (91%)
 rename src/{Features/VisualBasic/Portable/DocumentHighlighting => EditorFeatures/VisualBasic/HighlightReferences}/VisualBasicDocumentHighlightsService.vb (73%)
 create mode 100644 src/EditorFeatures/VisualBasic/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.vb
 delete mode 100644 src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService_Remote.cs
 delete mode 100644 src/Features/Core/Portable/DocumentHighlighting/DocumentHighlightingOptions.cs
 delete mode 100644 src/Features/Core/Portable/DocumentHighlighting/IRemoteDocumentHighlights.cs
 delete mode 100644 src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_DocumentHighlights.cs

diff --git a/src/EditorFeatures/CSharp/CSharpEditorFeatures.csproj b/src/EditorFeatures/CSharp/CSharpEditorFeatures.csproj
index 4369095c0de14..508f732f4d6cb 100644
--- a/src/EditorFeatures/CSharp/CSharpEditorFeatures.csproj
+++ b/src/EditorFeatures/CSharp/CSharpEditorFeatures.csproj
@@ -136,12 +136,14 @@
     <Compile Include="Highlighting\KeywordHighlighters\UnsafeStatementHighlighter.cs" />
     <Compile Include="Highlighting\KeywordHighlighters\UsingStatementHighlighter.cs" />
     <Compile Include="Highlighting\KeywordHighlighters\YieldStatementHighlighter.cs" />
+    <Compile Include="HighlightReferences\CSharpDocumentHighlightsService.cs" />
     <Compile Include="InlineRename\CSharpEditorInlineRenameService.cs" />
     <Compile Include="LanguageServices\CSharpContentTypeLanguageService.cs" />
     <Compile Include="LineSeparators\CSharpLineSeparatorService.cs" />
     <Compile Include="NavigationBar\CSharpNavigationBarItemService.cs" />
     <Compile Include="QuickInfo\SemanticQuickInfoProvider.cs" />
     <Compile Include="QuickInfo\SyntacticQuickInfoProvider.cs" />
+    <Compile Include="ReferenceHighlighting\ReferenceHighlightingAdditionalReferenceProvider.cs" />
     <Compile Include="RenameTracking\CSharpRenameTrackingCodeFixProvider.cs" />
     <Compile Include="RenameTracking\CSharpRenameTrackingLanguageHeuristicsService.cs" />
     <Compile Include="SplitStringLiteral\SplitStringLiteralCommandHandler.cs" />
diff --git a/src/EditorFeatures/CSharp/HighlightReferences/CSharpDocumentHighlightsService.cs b/src/EditorFeatures/CSharp/HighlightReferences/CSharpDocumentHighlightsService.cs
new file mode 100644
index 0000000000000..c1f3baf669ed0
--- /dev/null
+++ b/src/EditorFeatures/CSharp/HighlightReferences/CSharpDocumentHighlightsService.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Composition;
+using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Host.Mef;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.HighlightReferences
+{
+    [ExportLanguageService(typeof(IDocumentHighlightsService), LanguageNames.CSharp), Shared]
+    internal class CSharpDocumentHighlightsService : AbstractDocumentHighlightsService
+    {
+    }
+}
diff --git a/src/Features/CSharp/Portable/DocumentHighlighting/CSharpDocumentHighlightsService.cs b/src/EditorFeatures/CSharp/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.cs
similarity index 70%
rename from src/Features/CSharp/Portable/DocumentHighlighting/CSharpDocumentHighlightsService.cs
rename to src/EditorFeatures/CSharp/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.cs
index 4788978fd5719..2321c81cc552e 100644
--- a/src/Features/CSharp/Portable/DocumentHighlighting/CSharpDocumentHighlightsService.cs
+++ b/src/EditorFeatures/CSharp/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.cs
@@ -1,31 +1,32 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Collections.Immutable;
+using System.Collections.Generic;
 using System.Composition;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.DocumentHighlighting;
+using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.CSharp.DocumentHighlighting
+namespace Microsoft.CodeAnalysis.Editor.CSharp.ReferenceHighlighting
 {
-    [ExportLanguageService(typeof(IDocumentHighlightsService), LanguageNames.CSharp), Shared]
-    internal class CSharpDocumentHighlightsService : AbstractDocumentHighlightsService
+    [ExportLanguageService(typeof(IReferenceHighlightingAdditionalReferenceProvider), LanguageNames.CSharp), Shared]
+    internal class ReferenceHighlightingAdditionalReferenceProvider : IReferenceHighlightingAdditionalReferenceProvider
     {
-        protected override async Task<ImmutableArray<Location>> GetAdditionalReferencesAsync(
+        public async Task<IEnumerable<Location>> GetAdditionalReferencesAsync(
             Document document, ISymbol symbol, CancellationToken cancellationToken)
         {
             // The FindRefs engine won't find references through 'var' for performance reasons.
             // Also, they are not needed for things like rename/sig change, and the normal find refs
-            // feature.  However, we would like the results to be highlighted to get a good experience
+            // feature.  However, we would lke the results to be highlighted to get a good experience
             // while editing (especially since highlighting may have been invoked off of 'var' in
             // the first place).
             //
             // So we look for the references through 'var' directly in this file and add them to the
             // results found by the engine.
-            var results = ArrayBuilder<Location>.GetInstance();
+            List<Location> results = null;
 
             if (symbol is INamedTypeSymbol && symbol.Name != "var")
             {
@@ -51,13 +52,18 @@ protected override async Task<ImmutableArray<Location>> GetAdditionalReferencesA
 
                         if (originalSymbol.Equals(boundSymbol))
                         {
+                            if (results == null)
+                            {
+                                results = new List<Location>();
+                            }
+
                             results.Add(type.GetLocation());
                         }
                     }
                 }
             }
 
-            return results.ToImmutableAndFree();
+            return results ?? SpecializedCollections.EmptyEnumerable<Location>();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/EditorFeatures/Core/EditorFeatures.csproj b/src/EditorFeatures/Core/EditorFeatures.csproj
index e7809e7b20f5a..3a5b371a27e54 100644
--- a/src/EditorFeatures/Core/EditorFeatures.csproj
+++ b/src/EditorFeatures/Core/EditorFeatures.csproj
@@ -168,14 +168,6 @@
     <Compile Include="Implementation\Structure\BlockTagState.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionSetComparer.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionsSource.cs" />
-    <Compile Include="ReferenceHighlighting\NagivateToHighlightReferenceCommandHandler.cs" />
-    <Compile Include="ReferenceHighlighting\NagivateToHighlightReferenceCommandHandler.StartComparer.cs" />
-    <Compile Include="ReferenceHighlighting\ReferenceHighlightingViewTaggerProvider.cs" />
-    <Compile Include="ReferenceHighlighting\Tags\DefinitionHighlightTag.cs" />
-    <Compile Include="ReferenceHighlighting\Tags\DefinitionHighlightTagDefinition.cs" />
-    <Compile Include="ReferenceHighlighting\Tags\ReferenceHighlightTag.cs" />
-    <Compile Include="ReferenceHighlighting\Tags\WrittenReferenceHighlightTag.cs" />
-    <Compile Include="ReferenceHighlighting\Tags\WrittenReferenceHighlightTagDefinition.cs" />
     <Compile Include="SymbolSearch\IAddReferenceDatabaseWrapper.cs" />
     <Compile Include="SymbolSearch\IDatabaseFactoryService.cs" />
     <Compile Include="SymbolSearch\IDelayService.cs" />
@@ -638,6 +630,8 @@
     <Compile Include="Implementation\Peek\PeekableItemSource.cs" />
     <Compile Include="Implementation\Peek\PeekableItemSourceProvider.cs" />
     <Compile Include="Implementation\Peek\PeekHelpers.cs" />
+    <Compile Include="Implementation\ReferenceHighlighting\WrittenReferenceHighlightTag.cs" />
+    <Compile Include="Implementation\ReferenceHighlighting\WrittenReferenceHighlightTagDefinition.cs" />
     <Compile Include="Implementation\RenameTracking\IRenameTrackingLanguageHeuristicsService.cs" />
     <Compile Include="Implementation\RenameTracking\RenameTrackingCancellationCommandHandler.cs" />
     <Compile Include="Implementation\RenameTracking\RenameTrackingTagDefinition.cs" />
@@ -649,6 +643,15 @@
     <Compile Include="Implementation\Preview\PreviewConflictViewTaggerProvider.cs" />
     <Compile Include="Implementation\Preview\PreviewFactoryService.cs" />
     <Compile Include="Implementation\Preview\PreviewWarningViewTaggerProvider.cs" />
+    <Compile Include="Implementation\ReferenceHighlighting\AbstractDocumentHighlightsService.cs" />
+    <Compile Include="Implementation\ReferenceHighlighting\DefinitionHighlightTag.cs" />
+    <Compile Include="Implementation\ReferenceHighlighting\DefinitionHighlightTagDefinition.cs" />
+    <Compile Include="Implementation\ReferenceHighlighting\IDocumentHighlightsService.cs" />
+    <Compile Include="Implementation\ReferenceHighlighting\IReferenceHighlightingAdditionalReferenceProvider.cs" />
+    <Compile Include="Implementation\ReferenceHighlighting\NagivateToHighlightReferenceCommandHandler.cs" />
+    <Compile Include="Implementation\ReferenceHighlighting\NagivateToHighlightReferenceCommandHandler.StartComparer.cs" />
+    <Compile Include="Implementation\ReferenceHighlighting\ReferenceHighlightingViewTaggerProvider.cs" />
+    <Compile Include="Implementation\ReferenceHighlighting\ReferenceHighlightTag.cs" />
     <Compile Include="Implementation\RenameTracking\AbstractRenameTrackingCodeFixProvider.cs" />
     <Compile Include="Implementation\RenameTracking\RenameTrackingDiagnosticAnalyzer.cs" />
     <Compile Include="Implementation\RenameTracking\RenameTrackingTaggerProvider.cs" />
diff --git a/src/EditorFeatures/Core/Implementation/Preview/PreviewReferenceHighlightingTaggerProvider.cs b/src/EditorFeatures/Core/Implementation/Preview/PreviewReferenceHighlightingTaggerProvider.cs
index 5c90ff6b8f179..29a2060e254e3 100644
--- a/src/EditorFeatures/Core/Implementation/Preview/PreviewReferenceHighlightingTaggerProvider.cs
+++ b/src/EditorFeatures/Core/Implementation/Preview/PreviewReferenceHighlightingTaggerProvider.cs
@@ -6,7 +6,7 @@
 using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Text.Tagging;
 using Microsoft.VisualStudio.Utilities;
-using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.Preview
 {
diff --git a/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/AbstractDocumentHighlightsService.cs
similarity index 82%
rename from src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService.cs
rename to src/EditorFeatures/Core/Implementation/ReferenceHighlighting/AbstractDocumentHighlightsService.cs
index 91b1933bd7692..8a90b0062620f 100644
--- a/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService.cs
+++ b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/AbstractDocumentHighlightsService.cs
@@ -14,47 +14,12 @@
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.DocumentHighlighting
+namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
 {
-    internal abstract partial class AbstractDocumentHighlightsService : IDocumentHighlightsService
+    internal abstract class AbstractDocumentHighlightsService : IDocumentHighlightsService
     {
         public async Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsAsync(
             Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken)
-        {
-            var (succeeded, highlights) = await GetDocumentHighlightsInRemoteProcessAsync(
-                document, position, documentsToSearch, cancellationToken).ConfigureAwait(false);
-
-            if (succeeded)
-            {
-                return highlights;
-            }
-
-            return await GetDocumentHighlightsInCurrentProcessAsync(
-                document, position, documentsToSearch, cancellationToken).ConfigureAwait(false);
-        }
-
-        private async Task<(bool succeeded, ImmutableArray<DocumentHighlights> highlights)> GetDocumentHighlightsInRemoteProcessAsync(
-            Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken)
-        {
-            using (var session = await TryGetRemoteSessionAsync(
-                document.Project.Solution, cancellationToken).ConfigureAwait(false))
-            {
-                if (session == null)
-                {
-                    return (succeeded: false, ImmutableArray<DocumentHighlights>.Empty);
-                }
-
-                var result = await session.InvokeAsync<SerializableDocumentHighlights[]>(
-                    nameof(IRemoteDocumentHighlights.GetDocumentHighlightsAsync),
-                    document.Id,
-                    position,
-                    documentsToSearch.Select(d => d.Id).ToArray()).ConfigureAwait(false);
-                return (true, SerializableDocumentHighlights.Rehydrate(result, document.Project.Solution));
-            }
-        }
-
-        private async Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsInCurrentProcessAsync(
-            Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken)
         {
             // use speculative semantic model to see whether we are on a symbol we can do HR
             var span = new TextSpan(position, 0);
@@ -76,11 +41,11 @@ private async Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsInCu
 
             // Get unique tags for referenced symbols
             return await GetTagsForReferencedSymbolAsync(
-                new SymbolAndProjectId(symbol, document.Project.Id), documentsToSearch,
+                new SymbolAndProjectId(symbol, document.Project.Id), documentsToSearch, 
                 solution, cancellationToken).ConfigureAwait(false);
         }
 
-        private static async Task<ISymbol> GetSymbolToSearchAsync(Document document, int position, SemanticModel semanticModel, ISymbol symbol, CancellationToken cancellationToken)
+        private async Task<ISymbol> GetSymbolToSearchAsync(Document document, int position, SemanticModel semanticModel, ISymbol symbol, CancellationToken cancellationToken)
         {
             // see whether we can use the symbol as it is
             var currentSemanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
@@ -117,7 +82,7 @@ await SymbolFinder.FindReferencesAsync(
             return ImmutableArray<DocumentHighlights>.Empty;
         }
 
-        private static bool ShouldConsiderSymbol(ISymbol symbol)
+        private bool ShouldConsiderSymbol(ISymbol symbol)
         {
             switch (symbol.Kind)
             {
@@ -167,13 +132,19 @@ private async Task<ImmutableArray<DocumentHighlights>> FilterAndCreateSpansAsync
                 documentsToSearch, cancellationToken).ConfigureAwait(false);
         }
 
-        protected virtual Task<ImmutableArray<Location>> GetAdditionalReferencesAsync(
+        private Task<IEnumerable<Location>> GetAdditionalReferencesAsync(
             Document document, ISymbol symbol, CancellationToken cancellationToken)
         {
-            return SpecializedTasks.EmptyImmutableArray<Location>();
+            var additionalReferenceProvider = document.Project.LanguageServices.GetService<IReferenceHighlightingAdditionalReferenceProvider>();
+            if (additionalReferenceProvider != null)
+            {
+                return additionalReferenceProvider.GetAdditionalReferencesAsync(document, symbol, cancellationToken);
+            }
+
+            return Task.FromResult(SpecializedCollections.EmptyEnumerable<Location>());
         }
 
-        private static async Task<ImmutableArray<DocumentHighlights>> CreateSpansAsync(
+        private async Task<ImmutableArray<DocumentHighlights>> CreateSpansAsync(
             Solution solution,
             ISymbol symbol,
             IEnumerable<ReferencedSymbol> references,
@@ -281,7 +252,7 @@ private static bool ShouldIncludeDefinition(ISymbol symbol)
             return true;
         }
 
-        private static async Task AddLocationSpan(Location location, Solution solution, HashSet<DocumentSpan> spanSet, MultiDictionary<Document, HighlightSpan> tagList, HighlightSpanKind kind, CancellationToken cancellationToken)
+        private async Task AddLocationSpan(Location location, Solution solution, HashSet<DocumentSpan> spanSet, MultiDictionary<Document, HighlightSpan> tagList, HighlightSpanKind kind, CancellationToken cancellationToken)
         {
             var span = await GetLocationSpanAsync(solution, location, cancellationToken).ConfigureAwait(false);
             if (span != null && !spanSet.Contains(span.Value))
@@ -291,7 +262,7 @@ private static async Task AddLocationSpan(Location location, Solution solution,
             }
         }
 
-        private static async Task<DocumentSpan?> GetLocationSpanAsync(
+        private async Task<DocumentSpan?> GetLocationSpanAsync(
             Solution solution, Location location, CancellationToken cancellationToken)
         {
             try
diff --git a/src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTag.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTag.cs
similarity index 88%
rename from src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTag.cs
rename to src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTag.cs
index 0b974c620bfa2..2f5873a759429 100644
--- a/src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTag.cs
+++ b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTag.cs
@@ -2,7 +2,7 @@
 
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 
-namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
 {
     internal class DefinitionHighlightTag : NavigableHighlightTag
     {
diff --git a/src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTagDefinition.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTagDefinition.cs
similarity index 92%
rename from src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTagDefinition.cs
rename to src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTagDefinition.cs
index 5580291757cf8..b5a8023f8297e 100644
--- a/src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTagDefinition.cs
+++ b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTagDefinition.cs
@@ -5,7 +5,7 @@
 using Microsoft.VisualStudio.Text.Classification;
 using Microsoft.VisualStudio.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
 {
     [Export(typeof(EditorFormatDefinition))]
     [Name(DefinitionHighlightTag.TagId)]
diff --git a/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs
similarity index 95%
rename from src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
rename to src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs
index 0e08d4418c4f5..f86be931963c1 100644
--- a/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
+++ b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs
@@ -1,12 +1,13 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.DocumentHighlighting
+namespace Microsoft.CodeAnalysis.Editor
 {
     internal enum HighlightSpanKind
     {
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IReferenceHighlightingAdditionalReferenceProvider.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IReferenceHighlightingAdditionalReferenceProvider.cs
new file mode 100644
index 0000000000000..694a5b6e505a2
--- /dev/null
+++ b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IReferenceHighlightingAdditionalReferenceProvider.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+{
+    internal interface IReferenceHighlightingAdditionalReferenceProvider : ILanguageService
+    {
+        Task<IEnumerable<Location>> GetAdditionalReferencesAsync(Document document, ISymbol symbol, CancellationToken cancellationToken);
+    }
+}
diff --git a/src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
similarity index 87%
rename from src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
rename to src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
index 125416fd75162..76b72d5268f3b 100644
--- a/src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
+++ b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
@@ -3,7 +3,7 @@
 using System.Collections.Generic;
 using Microsoft.VisualStudio.Text;
 
-namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
 {
     internal partial class NavigateToHighlightReferenceCommandHandler
     {
diff --git a/src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
similarity index 98%
rename from src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
rename to src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
index 07a6b67793a85..a0997e4009c8a 100644
--- a/src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
+++ b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
@@ -14,7 +14,7 @@
 using Microsoft.VisualStudio.Text.Tagging;
 using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
 {
     [ExportCommandHandler(PredefinedCommandHandlerNames.NavigateToHighlightedReference,
        ContentTypeNames.RoslynContentType)]
diff --git a/src/EditorFeatures/Core/ReferenceHighlighting/Tags/ReferenceHighlightTag.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightTag.cs
similarity index 87%
rename from src/EditorFeatures/Core/ReferenceHighlighting/Tags/ReferenceHighlightTag.cs
rename to src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightTag.cs
index 299c701a98780..6c7d2cddc337b 100644
--- a/src/EditorFeatures/Core/ReferenceHighlighting/Tags/ReferenceHighlightTag.cs
+++ b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightTag.cs
@@ -2,7 +2,7 @@
 
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 
-namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
 {
     internal class ReferenceHighlightTag : NavigableHighlightTag
     {
diff --git a/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
similarity index 98%
rename from src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
rename to src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
index e2367ad5f5d3d..cbad756b7bd6a 100644
--- a/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
+++ b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
@@ -6,7 +6,6 @@
 using System.ComponentModel.Composition;
 using System.Linq;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 using Microsoft.CodeAnalysis.Editor.Tagging;
@@ -22,7 +21,7 @@
 using Microsoft.VisualStudio.Utilities;
 using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
 {
     [Export(typeof(IViewTaggerProvider))]
     [ContentType(ContentTypeNames.RoslynContentType)]
diff --git a/src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTag.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTag.cs
similarity index 88%
rename from src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTag.cs
rename to src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTag.cs
index d6f8df3342be5..b4d35d64ae6b1 100644
--- a/src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTag.cs
+++ b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTag.cs
@@ -2,7 +2,7 @@
 
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 
-namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
 {
     internal class WrittenReferenceHighlightTag : NavigableHighlightTag
     {
diff --git a/src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTagDefinition.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTagDefinition.cs
similarity index 91%
rename from src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTagDefinition.cs
rename to src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTagDefinition.cs
index 74323824a5056..8db19cc5cb2b4 100644
--- a/src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTagDefinition.cs
+++ b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTagDefinition.cs
@@ -5,7 +5,7 @@
 using Microsoft.VisualStudio.Text.Classification;
 using Microsoft.VisualStudio.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
 {
     [Export(typeof(EditorFormatDefinition))]
     [Name(WrittenReferenceHighlightTag.TagId)]
diff --git a/src/EditorFeatures/Test2/ReferenceHighlighting/AbstractReferenceHighlightingTests.vb b/src/EditorFeatures/Test2/ReferenceHighlighting/AbstractReferenceHighlightingTests.vb
index 7c9591274611f..ab5ab6a8ab80b 100644
--- a/src/EditorFeatures/Test2/ReferenceHighlighting/AbstractReferenceHighlightingTests.vb
+++ b/src/EditorFeatures/Test2/ReferenceHighlighting/AbstractReferenceHighlightingTests.vb
@@ -1,8 +1,7 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports System.Threading
-Imports Microsoft.CodeAnalysis.DocumentHighlighting
-Imports Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
+Imports Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
 Imports Microsoft.CodeAnalysis.Editor.Shared.Extensions
 Imports Microsoft.CodeAnalysis.Editor.Shared.Options
 Imports Microsoft.CodeAnalysis.Editor.Shared.Tagging
@@ -17,17 +16,9 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.ReferenceHighlighting
 
     Public MustInherit Class AbstractReferenceHighlightingTests
         Protected Async Function VerifyHighlightsAsync(test As XElement, Optional optionIsEnabled As Boolean = True) As Tasks.Task
-            Await VerifyHighlightsAsync(test, optionIsEnabled, outOfProcess:=False)
-            Await VerifyHighlightsAsync(test, optionIsEnabled, outOfProcess:=True)
-        End Function
-
-        Private Async Function VerifyHighlightsAsync(test As XElement, optionIsEnabled As Boolean, outOfProcess As Boolean) As Tasks.Task
             Using workspace = TestWorkspace.Create(test)
                 WpfTestCase.RequireWpfFact($"{NameOf(AbstractReferenceHighlightingTests)}.VerifyHighlightsAsync creates asynchronous taggers")
 
-                workspace.Options = workspace.Options.WithChangedOption(
-                    DocumentHighlightingOptions.OutOfProcessAllowed, outOfProcess)
-
                 Dim tagProducer = New ReferenceHighlightingViewTaggerProvider(
                     workspace.GetService(Of IForegroundNotificationService),
                     workspace.GetService(Of ISemanticChangeNotificationService),
diff --git a/src/EditorFeatures/VisualBasic/BasicEditorFeatures.vbproj b/src/EditorFeatures/VisualBasic/BasicEditorFeatures.vbproj
index 79ee5ff8d6c4c..531d79a604a6f 100644
--- a/src/EditorFeatures/VisualBasic/BasicEditorFeatures.vbproj
+++ b/src/EditorFeatures/VisualBasic/BasicEditorFeatures.vbproj
@@ -129,6 +129,7 @@
     <Compile Include="Highlighting\KeywordHighlighters\XmlEmbeddedExpressionHighlighter.vb" />
     <Compile Include="Highlighting\KeywordHighlighters\XmlProcessingInstructionHighlighter.vb" />
     <Compile Include="Highlighting\KeywordHighlightingHelpers.vb" />
+    <Compile Include="HighlightReferences\VisualBasicDocumentHighlightsService.vb" />
     <Compile Include="ImplementAbstractClass\ImplementAbstractClassCommandHandler.vb" />
     <Compile Include="ImplementInterface\ImplementInterfaceCommandHandler.vb" />
     <Compile Include="InlineRename\VisualBasicEditorInlineRenameService.vb" />
@@ -154,6 +155,7 @@
     <Compile Include="NavigationBar\GenerateMethodItem.vb" />
     <Compile Include="NavigationBar\VisualBasicNavigationBarItemService.vb" />
     <Compile Include="QuickInfo\SemanticQuickInfoProvider.vb" />
+    <Compile Include="ReferenceHighlighting\ReferenceHighlightingAdditionalReferenceProvider.vb" />
     <Compile Include="RenameTracking\BasicRenameTrackingLanguageHeuristicsService.vb" />
     <Compile Include="RenameTracking\RenameTrackingCodeFixProvider.vb" />
     <Compile Include="TextStructureNavigation\TextStructureNavigatorProvider.vb" />
diff --git a/src/Features/VisualBasic/Portable/DocumentHighlighting/VisualBasicDocumentHighlightsService.vb b/src/EditorFeatures/VisualBasic/HighlightReferences/VisualBasicDocumentHighlightsService.vb
similarity index 73%
rename from src/Features/VisualBasic/Portable/DocumentHighlighting/VisualBasicDocumentHighlightsService.vb
rename to src/EditorFeatures/VisualBasic/HighlightReferences/VisualBasicDocumentHighlightsService.vb
index 2f925d3749ed3..b0693439b5de7 100644
--- a/src/Features/VisualBasic/Portable/DocumentHighlighting/VisualBasicDocumentHighlightsService.vb
+++ b/src/EditorFeatures/VisualBasic/HighlightReferences/VisualBasicDocumentHighlightsService.vb
@@ -1,13 +1,13 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports System.Composition
-Imports Microsoft.CodeAnalysis.DocumentHighlighting
+Imports Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
 Imports Microsoft.CodeAnalysis.Host.Mef
 
-Namespace Microsoft.CodeAnalysis.VisualBasic.DocumentHighlighting
+Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.HighlightReferences
     <ExportLanguageService(GetType(IDocumentHighlightsService), LanguageNames.VisualBasic), [Shared]>
     Friend Class VisualBasicDocumentHighlightsService
         Inherits AbstractDocumentHighlightsService
 
     End Class
-End Namespace
\ No newline at end of file
+End Namespace
diff --git a/src/EditorFeatures/VisualBasic/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.vb b/src/EditorFeatures/VisualBasic/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.vb
new file mode 100644
index 0000000000000..2c95b09d3a2fb
--- /dev/null
+++ b/src/EditorFeatures/VisualBasic/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.vb
@@ -0,0 +1,18 @@
+' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+Imports System.Composition
+Imports System.Threading
+Imports System.Threading.Tasks
+Imports Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+Imports Microsoft.CodeAnalysis.Host.Mef
+
+Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.ReferenceHighlighting
+    <ExportLanguageService(GetType(IReferenceHighlightingAdditionalReferenceProvider), LanguageNames.VisualBasic), [Shared]>
+    Friend Class ReferenceHighlightingAdditionalReferenceProvider
+        Implements IReferenceHighlightingAdditionalReferenceProvider
+
+        Public Function GetAdditionalReferencesAsync(document As Document, symbol As ISymbol, cancellationToken As CancellationToken) As Task(Of IEnumerable(Of Location)) Implements IReferenceHighlightingAdditionalReferenceProvider.GetAdditionalReferencesAsync
+            Return SpecializedTasks.EmptyEnumerable(Of Location)()
+        End Function
+    End Class
+End Namespace
diff --git a/src/Features/CSharp/Portable/CSharpFeatures.csproj b/src/Features/CSharp/Portable/CSharpFeatures.csproj
index 0e91914a13210..07d23798af9ff 100644
--- a/src/Features/CSharp/Portable/CSharpFeatures.csproj
+++ b/src/Features/CSharp/Portable/CSharpFeatures.csproj
@@ -81,7 +81,6 @@
     </Compile>
     <Compile Include="DesignerAttributes\CSharpDesignerAttributeService.cs" />
     <Compile Include="Completion\CompletionProviders\DeclarationNameCompletionProvider.cs" />
-    <Compile Include="DocumentHighlighting\CSharpDocumentHighlightsService.cs" />
     <Compile Include="ImplementAbstractClass\CSharpImplementAbstractClassCodeFixProvider.cs" />
     <Compile Include="ImplementInterface\CSharpImplementInterfaceCodeFixProvider.cs" />
     <Compile Include="InitializeParameter\CSharpAddParameterCheckCodeRefactoringProvider.cs" />
diff --git a/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService_Remote.cs b/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService_Remote.cs
deleted file mode 100644
index 7efad4a9663df..0000000000000
--- a/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService_Remote.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Remote;
-
-namespace Microsoft.CodeAnalysis.DocumentHighlighting
-{
-    internal abstract partial class AbstractDocumentHighlightsService : IDocumentHighlightsService
-    {
-        private static async Task<RemoteHostClient.Session> TryGetRemoteSessionAsync(
-            Solution solution, CancellationToken cancellationToken)
-        {
-            var outOfProcessAllowed = solution.Workspace.Options.GetOption(DocumentHighlightingOptions.OutOfProcessAllowed);
-            if (!outOfProcessAllowed)
-            {
-                return null;
-            }
-
-            var client = await solution.Workspace.TryGetRemoteHostClientAsync(cancellationToken).ConfigureAwait(false);
-            if (client == null)
-            {
-                return null;
-            }
-
-            return await client.TryCreateCodeAnalysisServiceSessionAsync(
-                solution, cancellationToken).ConfigureAwait(false);
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/Features/Core/Portable/DocumentHighlighting/DocumentHighlightingOptions.cs b/src/Features/Core/Portable/DocumentHighlighting/DocumentHighlightingOptions.cs
deleted file mode 100644
index 0363999301f11..0000000000000
--- a/src/Features/Core/Portable/DocumentHighlighting/DocumentHighlightingOptions.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using Microsoft.CodeAnalysis.Options;
-
-namespace Microsoft.CodeAnalysis.DocumentHighlighting
-{
-    internal static class DocumentHighlightingOptions
-    {
-        private const string LocalRegistryPath = @"Roslyn\Features\DocumentHighlighting\";
-
-        public static readonly Option<bool> OutOfProcessAllowed = new Option<bool>(
-            nameof(DocumentHighlightingOptions), nameof(OutOfProcessAllowed), defaultValue: false,
-            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(OutOfProcessAllowed)));
-    }
-}
\ No newline at end of file
diff --git a/src/Features/Core/Portable/DocumentHighlighting/IRemoteDocumentHighlights.cs b/src/Features/Core/Portable/DocumentHighlighting/IRemoteDocumentHighlights.cs
deleted file mode 100644
index b58c6f35a18fd..0000000000000
--- a/src/Features/Core/Portable/DocumentHighlighting/IRemoteDocumentHighlights.cs
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Immutable;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Text;
-
-namespace Microsoft.CodeAnalysis.DocumentHighlighting
-{
-    internal interface IRemoteDocumentHighlights
-    {
-        Task<SerializableDocumentHighlights[]> GetDocumentHighlightsAsync(
-            DocumentId documentId, int position, DocumentId[] documentIdsToSearch);
-    }
-
-    internal struct SerializableDocumentHighlights
-    {
-        public DocumentId DocumentId;
-        public SerializableHighlightSpan[] HighlightSpans;
-
-        public static ImmutableArray<DocumentHighlights> Rehydrate(SerializableDocumentHighlights[] array, Solution solution)
-        {
-            var result = ArrayBuilder<DocumentHighlights>.GetInstance(array.Length);
-            foreach (var dehydrated in array)
-            {
-                result.Push(dehydrated.Rehydrate(solution));
-            }
-
-            return result.ToImmutableAndFree();
-        }
-
-        private DocumentHighlights Rehydrate(Solution solution)
-            => new DocumentHighlights(solution.GetDocument(DocumentId), SerializableHighlightSpan.Rehydrate(HighlightSpans));
-
-        public static SerializableDocumentHighlights[] Dehydrate(ImmutableArray<DocumentHighlights> array)
-        {
-            var result = new SerializableDocumentHighlights[array.Length];
-            var index = 0;
-            foreach (var highlights in array)
-            {
-                result[index] = Dehydrate(highlights);
-                index++;
-            }
-
-            return result;
-        }
-
-        private static SerializableDocumentHighlights Dehydrate(DocumentHighlights highlights)
-            => new SerializableDocumentHighlights
-            {
-                DocumentId = highlights.Document.Id,
-                HighlightSpans = SerializableHighlightSpan.Dehydrate(highlights.HighlightSpans)
-            };
-    }
-
-    internal struct SerializableHighlightSpan
-    {
-        public TextSpan TextSpan;
-        public HighlightSpanKind Kind;
-
-        internal static SerializableHighlightSpan[] Dehydrate(ImmutableArray<HighlightSpan> array)
-        {
-            var result = new SerializableHighlightSpan[array.Length];
-            var index = 0;
-            foreach (var span in array)
-            {
-                result[index] = Dehydrate(span);
-                index++;
-            }
-
-            return result;
-        }
-
-        private static SerializableHighlightSpan Dehydrate(HighlightSpan span)
-            => new SerializableHighlightSpan
-            {
-                Kind = span.Kind,
-                TextSpan = span.TextSpan
-            };
-
-        internal static ImmutableArray<HighlightSpan> Rehydrate(SerializableHighlightSpan[] array)
-        {
-            var result = ArrayBuilder<HighlightSpan>.GetInstance(array.Length);
-            foreach (var dehydrated in array)
-            {
-                result.Push(dehydrated.Rehydrate());
-            }
-
-            return result.ToImmutableAndFree();
-        }
-
-        private HighlightSpan Rehydrate()
-            => new HighlightSpan(TextSpan, Kind);
-    }
-}
\ No newline at end of file
diff --git a/src/Features/Core/Portable/Features.csproj b/src/Features/Core/Portable/Features.csproj
index 25a06421f4352..cff5327a8c52d 100644
--- a/src/Features/Core/Portable/Features.csproj
+++ b/src/Features/Core/Portable/Features.csproj
@@ -132,7 +132,6 @@
     <Compile Include="Diagnostics\DiagnosticArguments.cs" />
     <Compile Include="Diagnostics\DiagnosticResultSerializer.cs" />
     <Compile Include="Diagnostics\SymbolAnalysisContextExtensions.cs" />
-    <Compile Include="DocumentHighlighting\DocumentHighlightingOptions.cs" />
     <Compile Include="EncapsulateField\EncapsulateFieldRefactoringProvider.cs" />
     <Compile Include="ExtractInterface\ExtractInterfaceCodeRefactoringProvider.cs" />
     <Compile Include="CodeFixes\FixAllOccurrences\FixSomeCodeAction.cs" />
@@ -158,10 +157,6 @@
     <Compile Include="GenerateFromMembers\SelectedMemberInfo.cs" />
     <Compile Include="ImplementType\ImplementTypeOptions.cs" />
     <Compile Include="ImplementType\ImplementTypeOptionsProvider.cs" />
-    <Compile Include="DocumentHighlighting\AbstractDocumentHighlightsService.cs" />
-    <Compile Include="DocumentHighlighting\AbstractDocumentHighlightsService_Remote.cs" />
-    <Compile Include="DocumentHighlighting\IDocumentHighlightsService.cs" />
-    <Compile Include="DocumentHighlighting\IRemoteDocumentHighlights.cs" />
     <Compile Include="RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsCodeFixProvider.cs" />
     <Compile Include="RemoveUnnecessaryImports\IUnnecessaryImportsService.cs" />
     <Compile Include="NavigateTo\AbstractNavigateToSearchService.SearchResult.cs" />
diff --git a/src/Features/VisualBasic/Portable/BasicFeatures.vbproj b/src/Features/VisualBasic/Portable/BasicFeatures.vbproj
index 884a29b8778a4..7369bfd880ca4 100644
--- a/src/Features/VisualBasic/Portable/BasicFeatures.vbproj
+++ b/src/Features/VisualBasic/Portable/BasicFeatures.vbproj
@@ -66,7 +66,6 @@
       <Link>InternalUtilities\LambdaUtilities.vb</Link>
     </Compile>
     <Compile Include="AddPackage\VisualBasicAddSpecificPackageCodeFixProvider.vb" />
-    <Compile Include="DocumentHighlighting\VisualBasicDocumentHighlightsService.vb" />
     <Compile Include="InitializeParameter\InitializeParameterHelpers.vb" />
     <Compile Include="InitializeParameter\VisualBasicAddParameterCheckCodeRefactoringProvider.vb" />
     <Compile Include="ChangeSignature\ChangeSignatureFormattingRule.vb" />
diff --git a/src/VisualStudio/Core/Next/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs b/src/VisualStudio/Core/Next/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
index c8cf14161ae4b..e593f2f5ab596 100644
--- a/src/VisualStudio/Core/Next/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
+++ b/src/VisualStudio/Core/Next/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
@@ -7,7 +7,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.DocumentHighlighting;
+using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.FindUsages;
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.CodeAnalysis.Text;
diff --git a/src/VisualStudio/Core/Next/FindReferences/Contexts/WithReferencesFindUsagesContext.cs b/src/VisualStudio/Core/Next/FindReferences/Contexts/WithReferencesFindUsagesContext.cs
index 765612f4c86b2..9973893c2464d 100644
--- a/src/VisualStudio/Core/Next/FindReferences/Contexts/WithReferencesFindUsagesContext.cs
+++ b/src/VisualStudio/Core/Next/FindReferences/Contexts/WithReferencesFindUsagesContext.cs
@@ -8,7 +8,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Completion;
-using Microsoft.CodeAnalysis.DocumentHighlighting;
+using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.VisualStudio.Shell.FindAllReferences;
 using Roslyn.Utilities;
diff --git a/src/VisualStudio/Core/Next/FindReferences/Contexts/WithoutReferencesFindUsagesContext.cs b/src/VisualStudio/Core/Next/FindReferences/Contexts/WithoutReferencesFindUsagesContext.cs
index 2456a495cfef6..5a5f6a2b02bf8 100644
--- a/src/VisualStudio/Core/Next/FindReferences/Contexts/WithoutReferencesFindUsagesContext.cs
+++ b/src/VisualStudio/Core/Next/FindReferences/Contexts/WithoutReferencesFindUsagesContext.cs
@@ -3,7 +3,7 @@
 using System;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.DocumentHighlighting;
+using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.VisualStudio.Shell.FindAllReferences;
 using Roslyn.Utilities;
diff --git a/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs b/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs
index f32bade84b9c2..68c45919b30eb 100644
--- a/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs
+++ b/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs
@@ -7,11 +7,10 @@
 using System.Windows.Media;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Classification;
-using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.FindUsages;
 using Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo;
-using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Preview;
 using Microsoft.CodeAnalysis.FindUsages;
@@ -19,6 +18,7 @@
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Extensions;
 using Microsoft.VisualStudio.PlatformUI;
+using Microsoft.VisualStudio.Shell.TableControl;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
 
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpReferenceHighlighting.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpReferenceHighlighting.cs
index 8f527cbb55af5..627ac96efc079 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpReferenceHighlighting.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpReferenceHighlighting.cs
@@ -3,10 +3,11 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
+using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
 using Roslyn.Test.Utilities;
 using Xunit;
 
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicReferenceHighlighting.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicReferenceHighlighting.cs
index 86a0a05fec482..873349a13f999 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicReferenceHighlighting.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicReferenceHighlighting.cs
@@ -3,10 +3,11 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
+using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
 using Roslyn.Test.Utilities;
 using Xunit;
 
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/WellKnownTagNames.cs b/src/VisualStudio/IntegrationTest/TestUtilities/WellKnownTagNames.cs
index 98dd6cba799a0..d765685a409f3 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/WellKnownTagNames.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/WellKnownTagNames.cs
@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
-using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
 
 namespace Microsoft.VisualStudio.IntegrationTest.Utilities
 {
diff --git a/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj b/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj
index 68fe27e68b2f4..1d5b8a990240a 100644
--- a/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj
+++ b/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj
@@ -73,7 +73,6 @@
     </Compile>
     <Compile Include="Services\CodeAnalysisService_CodeLens.cs" />
     <Compile Include="Services\CodeAnalysisService_DesignerAttributes.cs" />
-    <Compile Include="Services\CodeAnalysisService_DocumentHighlights.cs" />
     <Compile Include="Services\CodeAnalysisService_TodoComments.cs" />
     <Compile Include="Services\CodeAnalysisService_SymbolFinder.cs" />
     <Compile Include="Services\RemoteSymbolSearchUpdateEngine.cs" />
diff --git a/src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_DocumentHighlights.cs b/src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_DocumentHighlights.cs
deleted file mode 100644
index b98c8e58a9146..0000000000000
--- a/src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_DocumentHighlights.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Immutable;
-using System.Linq;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.DocumentHighlighting;
-using Microsoft.CodeAnalysis.Shared.Extensions;
-
-namespace Microsoft.CodeAnalysis.Remote
-{
-    // root level service for all Roslyn services
-    internal partial class CodeAnalysisService : IRemoteDocumentHighlights
-    {
-        public async Task<SerializableDocumentHighlights[]> GetDocumentHighlightsAsync(
-            DocumentId documentId, int position, DocumentId[] documentIdsToSearch)
-        {
-            var solution = await GetSolutionAsync().ConfigureAwait(false);
-            var document = solution.GetDocument(documentId);
-            var documentsToSearch = ImmutableHashSet.CreateRange(documentIdsToSearch.Select(solution.GetDocument));
-
-            var service = document.GetLanguageService<IDocumentHighlightsService>();
-            var result = await service.GetDocumentHighlightsAsync(
-                document, position, documentsToSearch, CancellationToken).ConfigureAwait(false);
-
-            return SerializableDocumentHighlights.Dehydrate(result);
-        }
-    }
-}
\ No newline at end of file

From ba30bca7de123c048731e9296d05b9b735a4c379 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Mon, 8 May 2017 18:51:35 -0700
Subject: [PATCH 061/284] Tuple name completion should not include colon
 (#19335)

---
 .../CSharpCompletionCommandHandlerTests.vb    | 132 ++++++++++++++++++
 .../TupleNameCompletionProvider.cs            |  31 +++-
 2 files changed, 156 insertions(+), 7 deletions(-)

diff --git a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb
index 5bda149147ed8..709175329f8a5 100644
--- a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb
@@ -576,6 +576,138 @@ class C
             End Using
         End Function
 
+        <WpfFact, Trait(Traits.Feature, Traits.Features.Completion)>
+        <WorkItem(19335, "https://github.com/dotnet/roslyn/issues/19335")>
+        Public Async Function ColonInTupleNameInTupleLiteral() As Task
+            Using state = TestState.CreateCSharpTestState(
+                  <Document><![CDATA[
+class C
+{
+    public void M()
+    {
+        (int first, int second) t = ($$
+    }
+}]]></Document>)
+
+                state.SendTypeChars("fi")
+                Await state.AssertSelectedCompletionItem(displayText:="first:", isHardSelected:=True)
+                Assert.Equal("first", state.CurrentCompletionPresenterSession.SelectedItem.FilterText)
+                state.SendTypeChars(":")
+                Assert.Contains("(first:", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
+            End Using
+        End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.Completion)>
+        <WorkItem(19335, "https://github.com/dotnet/roslyn/issues/19335")>
+        Public Async Function ColonInExactTupleNameInTupleLiteral() As Task
+            Using state = TestState.CreateCSharpTestState(
+                  <Document><![CDATA[
+class C
+{
+    public void M()
+    {
+        (int first, int second) t = ($$
+    }
+}]]></Document>)
+
+                state.SendTypeChars("first")
+                Await state.AssertSelectedCompletionItem(displayText:="first:", isHardSelected:=True)
+                Assert.Equal("first", state.CurrentCompletionPresenterSession.SelectedItem.FilterText)
+                state.SendTypeChars(":")
+                Assert.Contains("(first:", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
+            End Using
+        End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.Completion)>
+        <WorkItem(19335, "https://github.com/dotnet/roslyn/issues/19335")>
+        Public Async Function ColonInTupleNameInTupleLiteralAfterComma() As Task
+            Using state = TestState.CreateCSharpTestState(
+                  <Document><![CDATA[
+class C
+{
+    public void M()
+    {
+        (int first, int second) t = (0, $$
+    }
+}]]></Document>)
+
+                state.SendTypeChars("se")
+                Await state.AssertSelectedCompletionItem(displayText:="second:", isHardSelected:=True)
+                Assert.Equal("second", state.CurrentCompletionPresenterSession.SelectedItem.FilterText)
+                state.SendTypeChars(":")
+                Assert.Contains("(0, second:", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
+            End Using
+        End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.Completion)>
+        <WorkItem(19335, "https://github.com/dotnet/roslyn/issues/19335")>
+        Public Async Function TabInTupleNameInTupleLiteral() As Task
+            Using state = TestState.CreateCSharpTestState(
+                  <Document><![CDATA[
+class C
+{
+    public void M()
+    {
+        (int first, int second) t = ($$
+    }
+}]]></Document>)
+
+                state.SendTypeChars("fi")
+                Await state.AssertSelectedCompletionItem(displayText:="first:", isHardSelected:=True)
+                Assert.Equal("first", state.CurrentCompletionPresenterSession.SelectedItem.FilterText)
+                state.SendTab()
+                state.SendTypeChars(":")
+                state.SendTypeChars("0")
+                Assert.Contains("(first:0", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
+            End Using
+        End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.Completion)>
+        <WorkItem(19335, "https://github.com/dotnet/roslyn/issues/19335")>
+        Public Async Function TabInExactTupleNameInTupleLiteral() As Task
+            Using state = TestState.CreateCSharpTestState(
+                  <Document><![CDATA[
+class C
+{
+    public void M()
+    {
+        (int first, int second) t = ($$
+    }
+}]]></Document>)
+
+                state.SendTypeChars("first")
+                Await state.AssertSelectedCompletionItem(displayText:="first:", isHardSelected:=True)
+                Assert.Equal("first", state.CurrentCompletionPresenterSession.SelectedItem.FilterText)
+                state.SendTab()
+                state.SendTypeChars(":")
+                state.SendTypeChars("0")
+                Assert.Contains("(first:0", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
+            End Using
+        End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.Completion)>
+        <WorkItem(19335, "https://github.com/dotnet/roslyn/issues/19335")>
+        Public Async Function TabInTupleNameInTupleLiteralAfterComma() As Task
+            Using state = TestState.CreateCSharpTestState(
+                  <Document><![CDATA[
+class C
+{
+    public void M()
+    {
+        (int first, int second) t = (0, $$
+    }
+}]]></Document>)
+
+                state.SendTypeChars("se")
+                Await state.AssertSelectedCompletionItem(displayText:="second:", isHardSelected:=True)
+                Assert.Equal("second", state.CurrentCompletionPresenterSession.SelectedItem.FilterText)
+                state.SendTab()
+                state.SendTypeChars(":")
+                state.SendTypeChars("1")
+                Assert.Contains("(0, second:1", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
+            End Using
+        End Function
+
         <WpfFact, Trait(Traits.Feature, Traits.Features.Completion)>
         <WorkItem(13527, "https://github.com/dotnet/roslyn/issues/13527")>
         Public Async Function TestKeywordInTupleLiteral() As Task
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/TupleNameCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/TupleNameCompletionProvider.cs
index cdc59e16a51a9..5f6e28fb619cb 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/TupleNameCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/TupleNameCompletionProvider.cs
@@ -2,20 +2,22 @@
 
 using System.Collections.Immutable;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Completion;
+using Microsoft.CodeAnalysis.Completion.Providers;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.CSharp.Completion.Providers
 {
     internal class TupleNameCompletionProvider : CommonCompletionProvider
     {
-        private static readonly CompletionItemRules _cachedRules = CompletionItemRules.Default
-            .WithCommitCharacterRule(CharacterSetModificationRule.Create(CharacterSetModificationKind.Remove, ':'));
+        private const string ColonString = ":";
 
         public override async Task ProvideCompletionsAsync(CompletionContext completionContext)
         {
@@ -40,7 +42,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext completionC
                     .Cast<INamedTypeSymbol>()
                     .ToImmutableArray();
 
-            AddItems(inferredTypes, index.Value, completionContext);
+            AddItems(inferredTypes, index.Value, completionContext, context.TargetToken.Parent.SpanStart);
         }
 
         private int? GetElementIndex(CSharpSyntaxContext context)
@@ -65,7 +67,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext completionC
             return null;
         }
 
-        private void AddItems(ImmutableArray<INamedTypeSymbol> inferredTypes, int index, CompletionContext context)
+        private void AddItems(ImmutableArray<INamedTypeSymbol> inferredTypes, int index, CompletionContext context, int spanStart)
         {
             foreach (var type in inferredTypes)
             {
@@ -74,11 +76,26 @@ private void AddItems(ImmutableArray<INamedTypeSymbol> inferredTypes, int index,
                     return;
                 }
 
+                // Note: the filter text does not include the ':'.  We want to ensure that if
+                // the user types the name exactly (up to the colon) that it is selected as an
+                // exact match.
+
                 var field = type.TupleElements[index];
-                var item = CommonCompletionItem.Create(
-                    field.Name + ":", _cachedRules, Glyph.FieldPublic);
-                context.AddItem(item);
+
+                context.AddItem(SymbolCompletionItem.CreateWithSymbolId(
+                  displayText: field.Name + ColonString,
+                  symbols: ImmutableArray.Create(field),
+                  rules: CompletionItemRules.Default,
+                  contextPosition: spanStart,
+                  filterText: field.Name));
             }
         }
+
+        protected override Task<TextChange?> GetTextChangeAsync(CompletionItem selectedItem, char? ch, CancellationToken cancellationToken)
+        {
+            return Task.FromResult<TextChange?>(new TextChange(
+                selectedItem.Span,
+                selectedItem.DisplayText.Substring(0, selectedItem.DisplayText.Length - ColonString.Length)));
+        }
     }
 }
\ No newline at end of file

From d6d1efa4eeebef75a0443917581548036ff99607 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Matou=C5=A1ek?=
 <tmat@users.noreply.github.com>
Date: Mon, 8 May 2017 21:22:57 -0700
Subject: [PATCH 062/284] Update to latest PDB reader/writer dependencies
 (#19302)

* Update versions

* Improve diagnostics
---
 NuGet.Config                                  |  1 +
 build/Targets/Packages.props                  |  6 +--
 .../CSharp/Test/Emit/PDB/PDBTests.cs          | 12 ++++--
 .../CodeAnalysisResources.Designer.cs         | 12 +++---
 .../Core/Portable/CodeAnalysisResources.resx  |  6 +--
 .../Portable/NativePdbWriter/PdbWriter.cs     | 40 +++++++++++--------
 6 files changed, 45 insertions(+), 32 deletions(-)

diff --git a/NuGet.Config b/NuGet.Config
index 43d2539f28212..0ea90a3391db9 100644
--- a/NuGet.Config
+++ b/NuGet.Config
@@ -19,6 +19,7 @@
     <add key="dotnet.myget.org symreader" value="https://dotnet.myget.org/F/symreader/api/v3/index.json" />
     <add key="dotnet.myget.org symreader-portable" value="https://dotnet.myget.org/F/symreader-portable/api/v3/index.json" />
     <add key="dotnet.myget.org symreader-converter" value="https://dotnet.myget.org/F/symreader-converter/api/v3/index.json" />
+    <add key="dotnet.myget.org symreader-native" value="https://dotnet.myget.org/F/symreader-native/api/v3/index.json" />
     <add key="dotnet.myget.org metadata-tools" value="https://dotnet.myget.org/F/metadata-tools/api/v3/index.json" />
     <add key="dotnet.myget.org interactive-window" value="https://dotnet.myget.org/F/interactive-window/api/v3/index.json" />
     <add key="dotnet.myget.org roslyn-master-nightly" value="https://dotnet.myget.org/F/roslyn-master-nightly/api/v3/index.json" />
diff --git a/build/Targets/Packages.props b/build/Targets/Packages.props
index d359d97267662..638af15a836ae 100644
--- a/build/Targets/Packages.props
+++ b/build/Targets/Packages.props
@@ -36,9 +36,9 @@
     <MicrosoftDiagnosticsRuntimeVersion>0.8.31-beta</MicrosoftDiagnosticsRuntimeVersion>
     <MicrosoftDiagnosticsTracingTraceEventVersion>1.0.35</MicrosoftDiagnosticsTracingTraceEventVersion>
     <MicrosoftDiaSymReaderVersion>1.1.0</MicrosoftDiaSymReaderVersion>
-    <MicrosoftDiaSymReaderConverterXmlVersion>1.0.0-beta1-61618-01</MicrosoftDiaSymReaderConverterXmlVersion>
-    <MicrosoftDiaSymReaderNativeVersion>1.5.0</MicrosoftDiaSymReaderNativeVersion>
-    <MicrosoftDiaSymReaderPortablePdbVersion>1.2.0</MicrosoftDiaSymReaderPortablePdbVersion>
+    <MicrosoftDiaSymReaderConverterXmlVersion>1.0.0-beta1-61708-01</MicrosoftDiaSymReaderConverterXmlVersion>
+    <MicrosoftDiaSymReaderNativeVersion>1.6.0-beta2-25304</MicrosoftDiaSymReaderNativeVersion>
+    <MicrosoftDiaSymReaderPortablePdbVersion>1.3.0-beta1-61619-01</MicrosoftDiaSymReaderPortablePdbVersion>
     <MicrosoftDotNetIBCMerge>4.7.1-alpha-00001</MicrosoftDotNetIBCMerge>
     <MicrosoftIdentityModelClientsActiveDirectoryVersion>3.13.8</MicrosoftIdentityModelClientsActiveDirectoryVersion>
     <MicrosoftInternalPerformanceCodeMarkersDesignTimeVersion>15.0.26201-alpha</MicrosoftInternalPerformanceCodeMarkersDesignTimeVersion>
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
index 80adf674c9e72..fd713ce68d083 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
@@ -180,9 +180,11 @@ public void SymWriterErrors2()
                     embeddedTexts: null,
                     testData: new CompilationTestData() { SymWriterFactory = () => new object() });
 
+                var libName = $"Microsoft.DiaSymReader.Native.{(IntPtr.Size == 4 ? "x86" : "amd64")}.dll";
+
                 result.Diagnostics.Verify(
-                    // error CS0041: Unexpected error writing debug information -- 'Windows PDB writer is not available -- could not find Microsoft.DiaSymReader.Native.{0}.dll'
-                    Diagnostic(ErrorCode.FTL_DebugEmitFailure).WithArguments(string.Format(CodeAnalysisResources.SymWriterNotAvailable, (IntPtr.Size == 4) ? "x86" : "amd64")));
+                    // error CS0041: Unexpected error writing debug information -- 'The version of Windows PDB writer is older than required: 'Microsoft.DiaSymReader.Native.x86.dll''
+                    Diagnostic(ErrorCode.FTL_DebugEmitFailure).WithArguments(string.Format(CodeAnalysisResources.SymWriterOlderVersionThanRequired, libName)));
 
                 Assert.False(result.Success);
             }
@@ -213,9 +215,11 @@ public void SymWriterErrors3()
                     embeddedTexts: null,
                     testData: new CompilationTestData() { SymWriterFactory = () => new MockSymUnmanagedWriter() });
 
+                var libName = $"Microsoft.DiaSymReader.Native.{(IntPtr.Size == 4 ? "x86" : "amd64")}.dll";
+
                 result.Diagnostics.Verify(
-                    // error CS0041: Unexpected error writing debug information -- 'Windows PDB writer doesn't support deterministic compilation -- could not find Microsoft.DiaSymReader.Native.{0}.dll'
-                    Diagnostic(ErrorCode.FTL_DebugEmitFailure).WithArguments(string.Format(CodeAnalysisResources.SymWriterNotDeterministic, (IntPtr.Size == 4) ? "x86" : "amd64")));
+                    // error CS0041: Unexpected error writing debug information -- 'Windows PDB writer doesn't support deterministic compilation -- could not find {0}'
+                    Diagnostic(ErrorCode.FTL_DebugEmitFailure).WithArguments(string.Format(CodeAnalysisResources.SymWriterNotDeterministic, libName)));
 
                 Assert.False(result.Success);
             }
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
index f7d3bbd3e231d..478cae1ae4eae 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
@@ -1289,20 +1289,20 @@ internal static string Struct1 {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Windows PDB writer is not available -- could not find Microsoft.DiaSymReader.Native.{0}.dll.
+        ///   Looks up a localized string similar to Windows PDB writer doesn&apos;t support deterministic compilation: &apos;{0}&apos;.
         /// </summary>
-        internal static string SymWriterNotAvailable {
+        internal static string SymWriterNotDeterministic {
             get {
-                return ResourceManager.GetString("SymWriterNotAvailable", resourceCulture);
+                return ResourceManager.GetString("SymWriterNotDeterministic", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Windows PDB writer doesn&apos;t support deterministic compilation -- could not find Microsoft.DiaSymReader.Native.{0}.dll.
+        ///   Looks up a localized string similar to The version of Windows PDB writer is older than required: &apos;{0}&apos;.
         /// </summary>
-        internal static string SymWriterNotDeterministic {
+        internal static string SymWriterOlderVersionThanRequired {
             get {
-                return ResourceManager.GetString("SymWriterNotDeterministic", resourceCulture);
+                return ResourceManager.GetString("SymWriterOlderVersionThanRequired", resourceCulture);
             }
         }
         
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.resx b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
index 3af8d6f2de563..96cd5f06360ee 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.resx
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
@@ -465,10 +465,10 @@
     <value>Invalid data at offset {0}: {1}{2}*{3}{4}</value>
   </data>
   <data name="SymWriterNotDeterministic" xml:space="preserve">
-    <value>Windows PDB writer doesn't support deterministic compilation -- could not find Microsoft.DiaSymReader.Native.{0}.dll</value>
+    <value>Windows PDB writer doesn't support deterministic compilation: '{0}'</value>
   </data>
-  <data name="SymWriterNotAvailable" xml:space="preserve">
-    <value>Windows PDB writer is not available -- could not find Microsoft.DiaSymReader.Native.{0}.dll</value>
+  <data name="SymWriterOlderVersionThanRequired" xml:space="preserve">
+    <value>The version of Windows PDB writer is older than required: '{0}'</value>
   </data>
   <data name="RuleSetBadAttributeValue" xml:space="preserve">
     <value>The attribute {0} has an invalid value of {1}.</value>
diff --git a/src/Compilers/Core/Portable/NativePdbWriter/PdbWriter.cs b/src/Compilers/Core/Portable/NativePdbWriter/PdbWriter.cs
index e4b5a60e629ec..bcbb76264c431 100644
--- a/src/Compilers/Core/Portable/NativePdbWriter/PdbWriter.cs
+++ b/src/Compilers/Core/Portable/NativePdbWriter/PdbWriter.cs
@@ -736,17 +736,25 @@ private void DefineScopeLocals(LocalScope currentScope, StandaloneSignatureHandl
 
         private const string SymWriterClsid = "0AE2DEB0-F901-478b-BB9F-881EE8066788";
 
-        private static bool s_MicrosoftDiaSymReaderNativeLoadFailed;
+        private const string LegacyDiaSymReaderModuleName = "diasymreader.dll";
+        private const string DiaSymReaderModuleName32 = "Microsoft.DiaSymReader.Native.x86.dll";
+        private const string DiaSymReaderModuleName64 = "Microsoft.DiaSymReader.Native.amd64.dll";
+
+        private static string s_MicrosoftDiaSymReaderNativeLoadFailure;
 
         [DefaultDllImportSearchPaths(DllImportSearchPath.AssemblyDirectory | DllImportSearchPath.SafeDirectories)]
-        [DllImport("Microsoft.DiaSymReader.Native.x86.dll", EntryPoint = "CreateSymWriter")]
+        [DllImport(DiaSymReaderModuleName32, EntryPoint = "CreateSymWriter")]
         private extern static void CreateSymWriter32(ref Guid id, [MarshalAs(UnmanagedType.IUnknown)]out object symWriter);
 
         [DefaultDllImportSearchPaths(DllImportSearchPath.AssemblyDirectory | DllImportSearchPath.SafeDirectories)]
-        [DllImport("Microsoft.DiaSymReader.Native.amd64.dll", EntryPoint = "CreateSymWriter")]
+        [DllImport(DiaSymReaderModuleName64, EntryPoint = "CreateSymWriter")]
         private extern static void CreateSymWriter64(ref Guid id, [MarshalAs(UnmanagedType.IUnknown)]out object symWriter);
 
-        private static string PlatformId => (IntPtr.Size == 4) ? "x86" : "amd64";
+        private static string DiaSymReaderModuleName 
+            => (IntPtr.Size == 4) ? DiaSymReaderModuleName32 : DiaSymReaderModuleName64;
+
+        private static string LoadedDiaSymReaderModuleName
+            => s_MicrosoftDiaSymReaderNativeLoadFailure != null ? LegacyDiaSymReaderModuleName : DiaSymReaderModuleName;
 
         private static Type GetCorSymWriterSxSType()
         {
@@ -764,7 +772,7 @@ private static object CreateSymWriterWorker()
             object symWriter = null;
 
             // First try to load an implementation from Microsoft.DiaSymReader.Native, which supports determinism.
-            if (!s_MicrosoftDiaSymReaderNativeLoadFailed)
+            if (s_MicrosoftDiaSymReaderNativeLoadFailure == null)
             {
                 try
                 {
@@ -778,9 +786,9 @@ private static object CreateSymWriterWorker()
                         CreateSymWriter64(ref guid, out symWriter);
                     }
                 }
-                catch (Exception)
+                catch (Exception e)
                 {
-                    s_MicrosoftDiaSymReaderNativeLoadFailed = true;
+                    s_MicrosoftDiaSymReaderNativeLoadFailure = e.Message;
                     symWriter = null;
                 }
             }
@@ -806,25 +814,25 @@ public void SetMetadataEmitter(MetadataWriter metadataWriter)
                 }
                 catch (Exception)
                 {
-                    throw new NotSupportedException(string.Format(CodeAnalysisResources.SymWriterNotAvailable, PlatformId));
+                    throw new NotSupportedException(string.Format(CodeAnalysisResources.SymWriterOlderVersionThanRequired, LoadedDiaSymReaderModuleName));
                 }
 
                 // Correctness: If the stream is not specified or if it is non-empty the SymWriter appends data to it (provided it contains valid PDB)
                 // and the resulting PDB has Age = existing_age + 1.
                 _pdbStream = new ComMemoryStream();
 
-                if (_deterministic)
+                if (!_deterministic)
                 {
-                    if (!(symWriter is ISymUnmanagedWriter7))
-                    {
-                        throw new NotSupportedException(string.Format(CodeAnalysisResources.SymWriterNotDeterministic, PlatformId));
-                    }
-
-                    ((ISymUnmanagedWriter7)symWriter).InitializeDeterministic(new PdbMetadataWrapper(metadataWriter), _pdbStream);
+                    symWriter.Initialize(new PdbMetadataWrapper(metadataWriter), _fileName, _pdbStream, fullBuild: true);
+                }
+                else if (symWriter is ISymUnmanagedWriter7 symWriter7)
+                {
+                    symWriter7.InitializeDeterministic(new PdbMetadataWrapper(metadataWriter), _pdbStream);
                 }
                 else
                 {
-                    symWriter.Initialize(new PdbMetadataWrapper(metadataWriter), _fileName, _pdbStream, fullBuild: true);
+                    throw new NotSupportedException(s_MicrosoftDiaSymReaderNativeLoadFailure ??
+                        string.Format(CodeAnalysisResources.SymWriterNotDeterministic, LoadedDiaSymReaderModuleName));
                 }
 
                 _metadataWriter = metadataWriter;

From 8af036a83af9cef70a38fc1c59d3ca35388a3972 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Mon, 8 May 2017 21:32:58 -0700
Subject: [PATCH 063/284] Refout: disallow NoPia, best effort determinism,
 assembly redirect for CopyRefAssembly (#19326)

* Ref assemblies make a best effort to emit with determinism
* Fixing CopyRefAssembly message output
* CopyRefAssembly logs when input isn't ref assembly
* CopyRefAssembly does assembly redirect.
* Compact error codes for C# 7.1
---
 docs/features/refout.md                       |  11 +-
 .../Portable/CSharpResources.Designer.cs      |   9 ++
 .../CSharp/Portable/CSharpResources.resx      |   3 +
 .../CommandLine/CSharpCommandLineParser.cs    |   5 +
 .../Emitter/Model/NamedTypeSymbolAdapter.cs   |   1 -
 .../CSharp/Portable/Errors/ErrorCode.cs       |  11 +-
 .../Test/CommandLine/CommandLineTests.cs      |  44 ++++++-
 .../Test/Emit/Emit/CompilationEmitTests.cs    | 107 +++++++++++++++---
 .../Semantics/TargetTypedDefaultTests.cs      |  10 +-
 .../Test/Syntax/Diagnostics/DiagnosticTest.cs |  13 ++-
 .../Core/MSBuildTask/CopyRefAssembly.cs       |  30 +++--
 .../Core/MSBuildTask/ErrorString.Designer.cs  |   9 ++
 .../Core/MSBuildTask/ErrorString.resx         |   3 +
 .../CodeAnalysisResources.Designer.cs         |   9 ++
 .../Core/Portable/CodeAnalysisResources.resx  |   3 +
 .../Core/Portable/Compilation/Compilation.cs  |  12 +-
 .../Portable/Emit/CommonPEModuleBuilder.cs    |   2 +-
 .../VisualBasicCommandLineParser.vb           |   4 +
 .../VisualBasic/Portable/Errors/Errors.vb     |   1 +
 .../Portable/VBResources.Designer.vb          |   9 ++
 .../VisualBasic/Portable/VBResources.resx     |   3 +
 .../Test/CommandLine/CommandLineTests.vb      |  36 +++++-
 .../Test/Emit/Emit/CompilationEmitTests.vb    |  18 +++
 23 files changed, 301 insertions(+), 52 deletions(-)

diff --git a/docs/features/refout.md b/docs/features/refout.md
index 9ab450afc9ffc..81253cb00f310 100644
--- a/docs/features/refout.md
+++ b/docs/features/refout.md
@@ -37,11 +37,10 @@ The `/refout` parameter specifies a file path where the ref assembly should be o
 The `/refonly` parameter is a flag that indicates that a ref assembly should be output instead of an implementation assembly. 
 The `/refonly` parameter is not allowed together with the `/refout` parameter, as it doesn't make sense to have both the primary and secondary outputs be ref assemblies. Also, the `/refonly` parameter silently disables outputting PDBs, as ref assemblies cannot be executed. 
 The `/refonly` parameter translates to `EmitMetadataOnly` being `true`, and `IncludePrivateMembers` being `false` in the `Emit` API (see details below).
-Neither `/refonly` nor `/refout` are permitted with `/target:module` or `/addmodule` options.
-
-When the compiler produces documentation, the contents produced will match the APIs that go into the primary output. In other words, the documentation will be filtered down when using the `/refonly` parameter.
+Neither `/refonly` nor `/refout` are permitted with `/target:module`, `/addmodule`, or `/link:...` options.
 
 The compilation from the command-line will either produce both assemblies (implementation and ref) or neither. There is no "partial success" scenario.
+When the compiler produces documentation, it is un-affected by either the `/refonly` or `/refout` parameters.
 
 ### CscTask/CoreCompile
 The `CoreCompile` target will support a new output, called `IntermediateRefAssembly`, which parallels the existing `IntermediateAssembly`.
@@ -65,8 +64,10 @@ Going back to the 4 driving scenarios:
 
 ## Future
 As mentioned above, there may be further refinements after C# 7.1:
-- controlling internals (producing public ref assemblies)
-- produce ref assemblies even when there are errors outside method bodies (emitting error types when `EmitOptions.TolerateErrors` is set)
+- Controlling internals (producing public ref assemblies)
+- Produce ref assemblies even when there are errors outside method bodies (emitting error types when `EmitOptions.TolerateErrors` is set)
+- When the compiler produces documentation, the contents produced could be filtered down to match the APIs that go into the primary output. In other words, the documentation could be filtered down when using the `/refonly` parameter.
+
 
 ## Open questions
 - should explicit method implementations be included in ref assemblies?
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
index 24a49f2d8bd9f..5f2881190b3a9 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
+++ b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
@@ -6730,6 +6730,15 @@ internal static string ERR_NoDynamicPhantomOnBaseIndexer {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot embed types when using /refout or /refonly..
+        /// </summary>
+        internal static string ERR_NoEmbeddedTypeWhenRefOutOrRefOnly {
+            get {
+                return ResourceManager.GetString("ERR_NoEmbeddedTypeWhenRefOutOrRefOnly", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Program does not contain a static &apos;Main&apos; method suitable for an entry point.
         /// </summary>
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index 6aedd38c798ca..9a5efb8522168 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -2300,6 +2300,9 @@ If such a class is used as a base class and if the deriving class defines a dest
   <data name="ERR_NoNetModuleOutputWhenRefOutOrRefOnly" xml:space="preserve">
     <value>Cannot compile net modules when using /refout or /refonly.</value>
   </data>
+  <data name="ERR_NoEmbeddedTypeWhenRefOutOrRefOnly" xml:space="preserve">
+    <value>Cannot embed types when using /refout or /refonly.</value>
+  </data>
   <data name="ERR_OvlOperatorExpected" xml:space="preserve">
     <value>Overloadable operator expected</value>
   </data>
diff --git a/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs b/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
index c28578c8eb9b5..cbde4e6815d12 100644
--- a/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
+++ b/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
@@ -1178,6 +1178,11 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
                 AddDiagnostic(diagnostics, diagnosticOptions, ErrorCode.ERR_NoRefOutWhenRefOnly);
             }
 
+            if ((refOnly || outputRefFilePath != null) && metadataReferences.Any(r => r.Properties.EmbedInteropTypes))
+            {
+                AddDiagnostic(diagnostics, diagnosticOptions, ErrorCode.ERR_NoEmbeddedTypeWhenRefOutOrRefOnly);
+            }
+
             if (outputKind == OutputKind.NetModule && (refOnly || outputRefFilePath != null))
             {
                 AddDiagnostic(diagnostics, diagnosticOptions, ErrorCode.ERR_NoNetModuleOutputWhenRefOutOrRefOnly);
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs b/src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs
index cfbad7e754c4b..da2b554d0c6bd 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs
@@ -325,7 +325,6 @@ internal virtual IEnumerable<EventSymbol> GetEventsToEmit()
 
             foreach (var member in this.GetMembers())
             {
-                // PROTOTYPE(refout) Do something here?
                 if (member.Kind == SymbolKind.Method)
                 {
                     var method = (MethodSymbol)member;
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index e582e372c0c04..68c162402c5ba 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -1476,11 +1476,12 @@ internal enum ErrorCode
         WRN_Experimental = 8305,
         ERR_TupleInferredNamesNotAvailable = 8306,
 
-        ERR_NoRefOutWhenRefOnly = 8355,
-        ERR_NoNetModuleOutputWhenRefOutOrRefOnly = 8356,
+        ERR_NoRefOutWhenRefOnly = 8307,
+        ERR_NoNetModuleOutputWhenRefOutOrRefOnly = 8308,
+        ERR_NoEmbeddedTypeWhenRefOutOrRefOnly = 8309,
 
-        ERR_BadDynamicMethodArgDefaultLiteral = 9000,
-        ERR_DefaultLiteralNotValid = 9001,
-        WRN_DefaultInSwitch = 9002,
+        ERR_BadDynamicMethodArgDefaultLiteral = 8310,
+        ERR_DefaultLiteralNotValid = 8311,
+        WRN_DefaultInSwitch = 8312,
     }
 }
diff --git a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
index a7c09bb93d260..616e19367c623 100644
--- a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
+++ b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
@@ -2886,6 +2886,18 @@ public void ParseOut()
                 // error CS8301: Do not use refout when using refonly.
                 Diagnostic(ErrorCode.ERR_NoRefOutWhenRefOnly).WithLocation(1, 1));
 
+            parsedArgs = DefaultParse(new[] { @"/refout:ref.dll", "/link:b", "a.cs" }, baseDirectory);
+            parsedArgs.Errors.Verify(
+                // error CS8357: Cannot embed types when using /refout or /refonly.
+                Diagnostic(ErrorCode.ERR_NoEmbeddedTypeWhenRefOutOrRefOnly).WithLocation(1, 1)
+                );
+
+            parsedArgs = DefaultParse(new[] { "/refonly", "/link:b", "a.cs" }, baseDirectory);
+            parsedArgs.Errors.Verify(
+                // error CS8357: Cannot embed types when using /refout or /refonly.
+                Diagnostic(ErrorCode.ERR_NoEmbeddedTypeWhenRefOutOrRefOnly).WithLocation(1, 1)
+                );
+
             parsedArgs = DefaultParse(new[] { "/refonly:incorrect", "a.cs" }, baseDirectory);
             parsedArgs.Errors.Verify(
                 // error CS2007: Unrecognized option: '/refonly:incorrect'
@@ -9067,6 +9079,11 @@ public static void Main()
     {
         System.Console.Write(""Hello"");
     }
+    /// <summary>Private method</summary>
+    private static void PrivateMethod()
+    {
+        System.Console.Write(""Private"");
+    }
 }");
 
             var outWriter = new StringWriter(CultureInfo.InvariantCulture);
@@ -9081,7 +9098,7 @@ public static void Main()
 
             MetadataReaderUtils.VerifyPEMetadata(exe,
                 new[] { "TypeDefinition:<Module>", "TypeDefinition:C" },
-                new[] { "MethodDefinition:Void Main()", "MethodDefinition:Void .ctor()" },
+                new[] { "MethodDefinition:Void Main()", "MethodDefinition:Void PrivateMethod()", "MethodDefinition:Void .ctor()" },
                 new[] { "CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute" }
                 );
 
@@ -9099,6 +9116,9 @@ public static void Main()
         <member name=""M:C.Main"">
             <summary>Main method</summary>
         </member>
+        <member name=""M:C.PrivateMethod"">
+            <summary>Private method</summary>
+        </member>
     </members>
 </doc>";
             Assert.Equal(expectedDoc, content.Trim());
@@ -9170,6 +9190,16 @@ private event Action E1
         remove { }
     }
     private event Action E2;
+
+    /// <summary>Private Class Field</summary>
+    private int field;
+    
+    /// <summary>Private Struct</summary>
+    private struct S
+    {
+        /// <summary>Private Struct Field</summary>
+        private int field;
+    }
 }");
 
             var outWriter = new StringWriter(CultureInfo.InvariantCulture);
@@ -9185,7 +9215,7 @@ private event Action E1
             // The types and members that are included needs further refinement.
             // See issue https://github.com/dotnet/roslyn/issues/17612
             MetadataReaderUtils.VerifyPEMetadata(refDll,
-                new[] { "TypeDefinition:<Module>", "TypeDefinition:C" },
+                new[] { "TypeDefinition:<Module>", "TypeDefinition:C", "TypeDefinition:S" },
                 new[] { "MethodDefinition:Void Main()", "MethodDefinition:Void .ctor()" },
                 new[] { "CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "ReferenceAssemblyAttribute" }
                 );
@@ -9207,10 +9237,20 @@ private event Action E1
         <member name=""M:C.Main"">
             <summary>Main method</summary>
         </member>
+        <member name=""F:C.field"">
+            <summary>Private Class Field</summary>
+        </member>
+        <member name=""T:C.S"">
+            <summary>Private Struct</summary>
+        </member>
+        <member name=""F:C.S.field"">
+            <summary>Private Struct Field</summary>
+        </member>
     </members>
 </doc>";
             Assert.Equal(expectedDoc, content.Trim());
 
+
             // Clean up temp files
             CleanupAllGeneratedFiles(dir.Path);
         }
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
index 77ed494cf7dc7..dfe2050db72b5 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
@@ -261,11 +261,11 @@ internal static void Main()
                 emitResult.Diagnostics.Verify();
 
                 VerifyEntryPoint(output, expectZero: false);
-                VerifyMethods(output, new[] { "void C.Main()", "C..ctor()" });
+                VerifyMethods(output, "C", new[] { "void C.Main()", "C..ctor()" });
                 VerifyMvid(output, hasMvidSection: false);
 
                 VerifyEntryPoint(metadataOutput, expectZero: true);
-                VerifyMethods(metadataOutput, new[] { "C..ctor()" });
+                VerifyMethods(metadataOutput, "C", new[] { "C..ctor()" });
                 VerifyMvid(metadataOutput, hasMvidSection: true);
             }
 
@@ -399,9 +399,9 @@ public class C
                 Assert.True(emitResult.Success);
                 emitResult.Diagnostics.Verify();
 
-                VerifyMethods(output, new[] { "System.Int32 C.<PrivateSetter>k__BackingField", "System.Int32 C.PrivateSetter.get", "void C.PrivateSetter.set",
+                VerifyMethods(output, "C", new[] { "System.Int32 C.<PrivateSetter>k__BackingField", "System.Int32 C.PrivateSetter.get", "void C.PrivateSetter.set",
                     "C..ctor()", "System.Int32 C.PrivateSetter { get; private set; }" });
-                VerifyMethods(metadataOutput, new[] { "System.Int32 C.PrivateSetter.get", "C..ctor()", "System.Int32 C.PrivateSetter { get; }" });
+                VerifyMethods(metadataOutput, "C", new[] { "System.Int32 C.PrivateSetter.get", "C..ctor()", "System.Int32 C.PrivateSetter { get; }" });
                 VerifyMvid(output, hasMvidSection: false);
                 VerifyMvid(metadataOutput, hasMvidSection: true);
             }
@@ -425,9 +425,9 @@ public class C
                 Assert.True(emitResult.Success);
                 emitResult.Diagnostics.Verify();
 
-                VerifyMethods(output, new[] { "System.Int32 C.<PrivateGetter>k__BackingField", "System.Int32 C.PrivateGetter.get", "void C.PrivateGetter.set",
+                VerifyMethods(output, "C", new[] { "System.Int32 C.<PrivateGetter>k__BackingField", "System.Int32 C.PrivateGetter.get", "void C.PrivateGetter.set",
                     "C..ctor()", "System.Int32 C.PrivateGetter { private get; set; }" });
-                VerifyMethods(metadataOutput, new[] { "void C.PrivateGetter.set", "C..ctor()", "System.Int32 C.PrivateGetter { set; }" });
+                VerifyMethods(metadataOutput, "C", new[] { "void C.PrivateGetter.set", "C..ctor()", "System.Int32 C.PrivateGetter { set; }" });
             }
         }
 
@@ -449,9 +449,9 @@ public class C
                 Assert.True(emitResult.Success);
                 emitResult.Diagnostics.Verify();
 
-                VerifyMethods(output, new[] { "System.Int32 C.this[System.Int32 i].get", "void C.this[System.Int32 i].set",
+                VerifyMethods(output, "C", new[] { "System.Int32 C.this[System.Int32 i].get", "void C.this[System.Int32 i].set",
                     "C..ctor()", "System.Int32 C.this[System.Int32 i] { private get; set; }" });
-                VerifyMethods(metadataOutput, new[] { "void C.this[System.Int32 i].set", "C..ctor()",
+                VerifyMethods(metadataOutput, "C", new[] { "void C.this[System.Int32 i].set", "C..ctor()",
                     "System.Int32 C.this[System.Int32 i] { set; }" });
             }
         }
@@ -478,9 +478,9 @@ public sealed override int Property { set { } }
                 emitResult.Diagnostics.Verify();
                 Assert.True(emitResult.Success);
 
-                VerifyMethods(output, new[] { "void C.Property.set", "C..ctor()", "System.Int32 C.Property.get", "System.Int32 C.Property { internal get; set; }" });
+                VerifyMethods(output, "C", new[] { "void C.Property.set", "C..ctor()", "System.Int32 C.Property.get", "System.Int32 C.Property { internal get; set; }" });
                 // A getter is synthesized on C.Property so that it can be marked as sealed. It is emitted despite being internal because it is virtual.
-                VerifyMethods(metadataOutput, new[] {  "void C.Property.set", "C..ctor()", "System.Int32 C.Property.get", "System.Int32 C.Property { internal get; set; }" });
+                VerifyMethods(metadataOutput, "C", new[] {  "void C.Property.set", "C..ctor()", "System.Int32 C.Property.get", "System.Int32 C.Property { internal get; set; }" });
             }
         }
 
@@ -504,7 +504,7 @@ public event System.Action PrivateRemover { add { } private remove { } }
                 );
         }
 
-        private static void VerifyMethods(MemoryStream stream, string[] expectedMethods)
+        private static void VerifyMethods(MemoryStream stream, string containingType, string[] expectedMethods)
         {
             stream.Position = 0;
             var metadataRef = AssemblyMetadata.CreateFromImage(stream.ToArray()).GetReference();
@@ -514,7 +514,7 @@ private static void VerifyMethods(MemoryStream stream, string[] expectedMethods)
 
             AssertEx.Equal(
                 expectedMethods,
-                compWithMetadata.GetMember<NamedTypeSymbol>("C").GetMembers().Select(m => m.ToTestDisplayString()));
+                compWithMetadata.GetMember<NamedTypeSymbol>(containingType).GetMembers().Select(m => m.ToTestDisplayString()));
         }
 
         [Fact]
@@ -824,6 +824,10 @@ string M()
                 ));
         }
 
+        /// <summary>
+        /// The client compilation should not be affected (except for some diagnostic differences)
+        /// by the library assembly only having metadata, or not including private members.
+        /// </summary>
         private void VerifyRefAssemblyClient(string lib_cs, string client_cs, Action<CSharpCompilation> validator, int debugFlag = -1)
         {
             // Whether the library is compiled in full, as metadata-only, or as a ref assembly should be transparent
@@ -859,6 +863,55 @@ private static void VerifyRefAssemblyClient(string lib_cs, string source, Action
             validator(comp);
         }
 
+        [Theory]
+        [InlineData("")]
+        [InlineData(@"[assembly: System.Reflection.AssemblyVersion(""1"")]")]
+        [InlineData(@"[assembly: System.Reflection.AssemblyVersion(""1.0.*"")]")]
+        public void RefAssembly_EmitAsDeterministic(string source)
+        {
+            var comp = CreateStandardCompilation(source, options: TestOptions.DebugDll.WithDeterministic(false));
+
+            var (image1, refImage1) = emitRefOut();
+
+            // The resolution of the PE header time date stamp is seconds, and we want to make sure that has an opportunity to change
+            // between calls to Emit.
+            Thread.Sleep(TimeSpan.FromSeconds(1));
+            var (image2, refImage2) = emitRefOut();
+            var refImage3 = emitRefOnly();
+
+            AssertEx.Equal(refImage1, refImage2);
+            AssertEx.Equal(refImage1, refImage3);
+
+            var comp2 = CreateStandardCompilation(source, options: TestOptions.DebugDll.WithDeterministic(false));
+            var refImage4 = emitRefOnly();
+            AssertEx.Equal(refImage1, refImage4);
+
+            (ImmutableArray<byte> image, ImmutableArray<byte> refImage) emitRefOut()
+            {
+                using (var output = new MemoryStream())
+                using (var metadataOutput = new MemoryStream())
+                {
+                    var options = EmitOptions.Default.WithIncludePrivateMembers(false);
+                    comp.VerifyEmitDiagnostics();
+                    var result = comp.Emit(output, metadataPEStream: metadataOutput,
+                        options: options);
+                    return (output.ToImmutable(), metadataOutput.ToImmutable());
+                }
+            }
+
+            ImmutableArray<byte> emitRefOnly()
+            {
+                using (var output = new MemoryStream())
+                {
+                    var options = EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false);
+                    comp.VerifyEmitDiagnostics();
+                    var result = comp.Emit(output,
+                        options: options);
+                    return output.ToImmutable();
+                }
+            }
+        }
+
         [Theory]
         [InlineData("public int M() { error(); }", true)]
         [InlineData("public int M() { error() }", false)] // This may get relaxed. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
@@ -1057,7 +1110,7 @@ public void EmitMetadataOnly_DisallowOutputtingNetModule()
         }
 
         [Fact]
-        public void EmitMetadata_AllowEmbedding()
+        public void RefAssembly_AllowEmbeddingPdb()
         {
             CSharpCompilation comp = CreateCompilation("", references: new[] { MscorlibRef },
                 options: TestOptions.DebugDll);
@@ -1069,7 +1122,7 @@ public void EmitMetadata_AllowEmbedding()
                     options: EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.Embedded).WithIncludePrivateMembers(false));
 
                 VerifyEmbeddedDebugInfo(output, new[] { DebugDirectoryEntryType.CodeView, DebugDirectoryEntryType.EmbeddedPortablePdb });
-                VerifyEmbeddedDebugInfo(metadataOutput, new DebugDirectoryEntryType[] { });
+                VerifyEmbeddedDebugInfo(metadataOutput, new DebugDirectoryEntryType[] { DebugDirectoryEntryType.Reproducible });
             }
 
             void VerifyEmbeddedDebugInfo(MemoryStream stream, DebugDirectoryEntryType[] expected)
@@ -1083,7 +1136,7 @@ void VerifyEmbeddedDebugInfo(MemoryStream stream, DebugDirectoryEntryType[] expe
         }
 
         [Fact]
-        public void EmitMetadataOnly_DisallowEmbedding()
+        public void EmitMetadataOnly_DisallowEmbeddingPdb()
         {
             CSharpCompilation comp = CreateCompilation("", references: new[] { MscorlibRef },
                 options: TestOptions.DebugDll);
@@ -1096,6 +1149,30 @@ public void EmitMetadataOnly_DisallowEmbedding()
             }
         }
 
+        [Fact]
+        public void RefAssembly_DisallowEmbeddingTypes()
+        {
+            CSharpCompilation comp = CreateCompilation("", options: TestOptions.DebugDll,
+                references: new MetadataReference[]
+                {
+                    TestReferences.SymbolsTests.NoPia.GeneralPia.WithEmbedInteropTypes(true)
+                });
+
+            using (var output = new MemoryStream())
+            {
+                Assert.Throws<ArgumentException>(() => comp.Emit(output,
+                    options: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)));
+            }
+
+            using (var output = new MemoryStream())
+            using (var metadataOutput = new MemoryStream())
+            {
+                Assert.Throws<ArgumentException>(() => comp.Emit(output,
+                    metadataPEStream: metadataOutput,
+                    options: EmitOptions.Default.WithIncludePrivateMembers(false)));
+            }
+        }
+
         [Fact]
         public void EmitMetadata()
         {
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/TargetTypedDefaultTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/TargetTypedDefaultTests.cs
index f59dff07b54fc..b73c38922472a 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/TargetTypedDefaultTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/TargetTypedDefaultTests.cs
@@ -1434,7 +1434,7 @@ static void M1()
 
             var comp = CreateStandardCompilation(source, parseOptions: TestOptions.Regular7_1);
             comp.VerifyDiagnostics(
-                // (7,14): error CS9000: Cannot use a default literal as an argument to a dynamically dispatched operation.
+                // (7,14): error CS8310: Cannot use a default literal as an argument to a dynamically dispatched operation.
                 //         d.M2(default);
                 Diagnostic(ErrorCode.ERR_BadDynamicMethodArgDefaultLiteral, "default").WithLocation(7, 14)
                 );
@@ -1524,7 +1524,7 @@ static void Main()
 
             var comp = CreateStandardCompilation(text, parseOptions: TestOptions.Regular7_1, options: TestOptions.DebugExe);
             comp.VerifyDiagnostics(
-                // (6,27): error CS9001: Use of default literal is not valid in this context
+                // (6,27): error CS8311: Use of default literal is not valid in this context
                 //         foreach (int x in default) { }
                 Diagnostic(ErrorCode.ERR_DefaultLiteralNotValid, "default").WithLocation(6, 27),
                 // (7,27): error CS0186: Use of null is not valid in this context
@@ -1549,7 +1549,7 @@ static void Main()
 ";
             var compilation = CreateCompilationWithMscorlibAndSystemCore(source, parseOptions: TestOptions.Regular7_1, references: new[] { SystemCoreRef });
             compilation.VerifyDiagnostics(
-                // (6,35): error CS9001: Use of default literal is not valid in this context
+                // (6,35): error CS8311: Use of default literal is not valid in this context
                 //         var q = from x in default select x;
                 Diagnostic(ErrorCode.ERR_DefaultLiteralNotValid, "select x").WithLocation(6, 35),
                 // (7,43): error CS1942: The type of the expression in the select clause is incorrect.  Type inference failed in the call to 'Select'.
@@ -1898,7 +1898,7 @@ static void M(int x)
 
             var comp = CreateStandardCompilation(source, parseOptions: TestOptions.Regular7_1, options: TestOptions.DebugExe);
             comp.VerifyDiagnostics(
-                // (12,18): warning CS9002: Did you mean to use the default switch label (`default:`) rather than `case default:`? If you really mean to use the default literal, consider `case (default):` or another literal (`case 0:` or `case null:`) as appropriate.
+                // (12,18): warning CS8312: Did you mean to use the default switch label (`default:`) rather than `case default:`? If you really mean to use the default literal, consider `case (default):` or another literal (`case 0:` or `case null:`) as appropriate.
                 //             case default:
                 Diagnostic(ErrorCode.WRN_DefaultInSwitch, "default").WithLocation(12, 18)
                 );
@@ -1931,7 +1931,7 @@ static void M(object x)
 
             var comp = CreateStandardCompilation(source, parseOptions: TestOptions.Regular7_1, options: TestOptions.DebugExe);
             comp.VerifyDiagnostics(
-                // (12,18): warning CS9002: Did you mean to use the default switch label (`default:`) rather than `case default:`? If you really mean to use the default literal, consider `case (default):` or another literal (`case 0:` or `case null:`) as appropriate.
+                // (12,18): warning CS8312: Did you mean to use the default switch label (`default:`) rather than `case default:`? If you really mean to use the default literal, consider `case (default):` or another literal (`case 0:` or `case null:`) as appropriate.
                 //             case default:
                 Diagnostic(ErrorCode.WRN_DefaultInSwitch, "default").WithLocation(12, 18)
                 );
diff --git a/src/Compilers/CSharp/Test/Syntax/Diagnostics/DiagnosticTest.cs b/src/Compilers/CSharp/Test/Syntax/Diagnostics/DiagnosticTest.cs
index b2fc07f7f8952..d55296b59c2cc 100644
--- a/src/Compilers/CSharp/Test/Syntax/Diagnostics/DiagnosticTest.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Diagnostics/DiagnosticTest.cs
@@ -183,9 +183,8 @@ static void Main()
         [Fact]
         public void WarningLevel_1()
         {
-            for (int i = 0; i < 10000; i++)
+            foreach (ErrorCode errorCode in Enum.GetValues(typeof(ErrorCode)))
             {
-                ErrorCode errorCode = (ErrorCode)i;
                 string errorCodeName = errorCode.ToString();
                 if (errorCodeName.StartsWith("WRN", StringComparison.Ordinal))
                 {
@@ -215,12 +214,15 @@ public void WarningLevel_2()
             Assert.Equal(3, ErrorFacts.GetWarningLevel(ErrorCode.WRN_IsDynamicIsConfusing));
             Assert.Equal(2, ErrorFacts.GetWarningLevel(ErrorCode.WRN_NoSources));
 
-            // There is space in the range of error codes from 7000-8999 that we might add for new errors in post-Dev10.
             // If a new warning is added, this test will fail and adding the new case with the expected error level will be required.
 
-            for (int i = 7000; i < 9000; i++)
+            foreach (ErrorCode errorCode in Enum.GetValues(typeof(ErrorCode)))
             {
-                ErrorCode errorCode = (ErrorCode)i;
+                if ((int)errorCode < 7000)
+                {
+                    continue;
+                }
+
                 string errorCodeName = errorCode.ToString();
                 if (errorCodeName.StartsWith("WRN", StringComparison.Ordinal))
                 {
@@ -244,6 +246,7 @@ public void WarningLevel_2()
                         case ErrorCode.WRN_AlignmentMagnitude:
                         case ErrorCode.WRN_TupleLiteralNameMismatch:
                         case ErrorCode.WRN_Experimental:
+                        case ErrorCode.WRN_DefaultInSwitch:
                             Assert.Equal(1, ErrorFacts.GetWarningLevel(errorCode));
                             break;
                         case ErrorCode.WRN_MainIgnored:
diff --git a/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs b/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs
index 5b12dc838c517..03b27b3c2904c 100644
--- a/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs
+++ b/src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs
@@ -20,6 +20,11 @@ public sealed class CopyRefAssembly : Task
         [Required]
         public string DestinationPath { get; set; }
 
+        static CopyRefAssembly()
+        {
+            AssemblyResolution.Install();
+        }
+
         public CopyRefAssembly()
         {
             TaskResources = ErrorString.ResourceManager;
@@ -45,20 +50,27 @@ public override bool Execute()
                     Log.LogMessageFromResources(MessageImportance.High, "CopyRefAssembly_BadSource3", SourcePath, e.Message, e.StackTrace);
                 }
 
-                try
+                if (source.Equals(Guid.Empty))
+                {
+                    Log.LogMessageFromResources(MessageImportance.High, "CopyRefAssembly_SourceNotRef1", SourcePath);
+                }
+                else
                 {
-                    Guid destination = ExtractMvid(DestinationPath);
+                    try
+                    {
+                        Guid destination = ExtractMvid(DestinationPath);
 
-                    if (source.Equals(destination))
+                        if (!source.Equals(Guid.Empty) && source.Equals(destination))
+                        {
+                            Log.LogMessageFromResources(MessageImportance.Low, "CopyRefAssembly_SkippingCopy1", DestinationPath);
+                            return true;
+                        }
+                    }
+                    catch (Exception)
                     {
-                        Log.LogMessageFromResources(MessageImportance.Low, "CopyRefAssembly_SkippingCopy1", DestinationPath);
-                        return true;
+                        Log.LogMessageFromResources(MessageImportance.High, "CopyRefAssembly_BadDestination1", DestinationPath);
                     }
                 }
-                catch (Exception)
-                {
-                    Log.LogMessage(MessageImportance.High, "CopyRefAssembly_BadDestination1", DestinationPath);
-                }
             }
 
             return Copy();
diff --git a/src/Compilers/Core/MSBuildTask/ErrorString.Designer.cs b/src/Compilers/Core/MSBuildTask/ErrorString.Designer.cs
index 560a55decf577..d4db8b30d05b1 100644
--- a/src/Compilers/Core/MSBuildTask/ErrorString.Designer.cs
+++ b/src/Compilers/Core/MSBuildTask/ErrorString.Designer.cs
@@ -98,6 +98,15 @@ internal static string CopyRefAssembly_SkippingCopy1 {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Could not extract the MVID from &quot;{0}&quot;. Are you sure it is a reference assembly?.
+        /// </summary>
+        internal static string CopyRefAssembly_SourceNotRef1 {
+            get {
+                return ResourceManager.GetString("CopyRefAssembly_SourceNotRef1", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to MSB3053: The assembly alias &quot;{1}&quot; on reference &quot;{0}&quot; contains illegal characters..
         /// </summary>
diff --git a/src/Compilers/Core/MSBuildTask/ErrorString.resx b/src/Compilers/Core/MSBuildTask/ErrorString.resx
index 9f6962ded7d75..ac0d63fc64e5e 100644
--- a/src/Compilers/Core/MSBuildTask/ErrorString.resx
+++ b/src/Compilers/Core/MSBuildTask/ErrorString.resx
@@ -154,6 +154,9 @@
   <data name="CopyRefAssembly_SkippingCopy1" xml:space="preserve">
     <value>Reference assembly "{0}" already has latest information. Leaving it untouched.</value>
   </data>
+  <data name="CopyRefAssembly_SourceNotRef1" xml:space="preserve">
+    <value>Could not extract the MVID from "{0}". Are you sure it is a reference assembly?</value>
+  </data>
   <data name="CopyRefAssembly_BadSource3" xml:space="preserve">
     <value>Failed to check the content hash of the source ref assembly '{0}': {1}
 {2}</value>
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
index 9a38358b5b06a..0a1d2c3f38c6a 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
@@ -477,6 +477,15 @@ internal static string EmbeddingPdbUnexpectedWhenEmittingMetadata {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Embedded interop type references should not be given when emitting a ref assembly..
+        /// </summary>
+        internal static string EmbedInteropTypesUnexpectedWhenEmittingRefAssembly {
+            get {
+                return ResourceManager.GetString("EmbedInteropTypesUnexpectedWhenEmittingRefAssembly", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to A key in the pathMap is empty..
         /// </summary>
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.resx b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
index 5843e7ac09b72..b0d49fe7d3b07 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.resx
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
@@ -333,6 +333,9 @@
   <data name="PdbStreamUnexpectedWhenEmittingMetadataOnly" xml:space="preserve">
     <value>PDB stream should not be given when emitting metadata only.</value>
   </data>
+  <data name="EmbedInteropTypesUnexpectedWhenEmittingRefAssembly" xml:space="preserve">
+    <value>Embedded interop type references should not be given when emitting a ref assembly.</value>
+  </data>
   <data name="MetadataPeStreamUnexpectedWhenEmittingMetadataOnly" xml:space="preserve">
     <value>Metadata PE stream should not be given when emitting metadata only.</value>
   </data>
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index d1d232aa1fafc..be14eaa324e02 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -2087,6 +2087,13 @@ public EmitResult Emit(
                 throw new ArgumentException(CodeAnalysisResources.IncludingPrivateMembersUnexpectedWhenEmittingToMetadataPeStream, nameof(metadataPEStream));
             }
 
+            if ((metadataPEStream != null || options?.EmitMetadataOnly == true) &&
+                options?.IncludePrivateMembers == false &&
+                References.Any(r => r.Properties.EmbedInteropTypes))
+            {
+                throw new ArgumentException(CodeAnalysisResources.EmbedInteropTypesUnexpectedWhenEmittingRefAssembly, nameof(metadataPEStream));
+            }
+
             if (options?.DebugInformationFormat == DebugInformationFormat.Embedded &&
                 options?.EmitMetadataOnly == true)
             {
@@ -2636,6 +2643,7 @@ internal static bool SerializePeToStream(
             bool emitSecondaryAssembly = getMetadataPeStreamOpt != null;
 
             bool includePrivateMembersOnPrimaryOutput = metadataOnly ? includePrivateMembers : true;
+            bool deterministicPrimaryOutput = (metadataOnly && !includePrivateMembers) || isDeterministic;
             if (!Cci.PeWriter.WritePeToStream(
                 new EmitContext(moduleBeingBuilt, null, metadataDiagnostics, metadataOnly, includePrivateMembersOnPrimaryOutput),
                 messageProvider,
@@ -2644,7 +2652,7 @@ internal static bool SerializePeToStream(
                 nativePdbWriterOpt,
                 pdbPathOpt,
                 metadataOnly,
-                isDeterministic,
+                deterministicPrimaryOutput,
                 emitTestCoverageData,
                 cancellationToken))
             {
@@ -2665,7 +2673,7 @@ internal static bool SerializePeToStream(
                     nativePdbWriterOpt: null,
                     pdbPathOpt: null,
                     metadataOnly: true,
-                    isDeterministic: isDeterministic,
+                    isDeterministic: true,
                     emitTestCoverageData: false,
                     cancellationToken: cancellationToken))
                 {
diff --git a/src/Compilers/Core/Portable/Emit/CommonPEModuleBuilder.cs b/src/Compilers/Core/Portable/Emit/CommonPEModuleBuilder.cs
index bdf7c957645d5..5cf8461f793e8 100644
--- a/src/Compilers/Core/Portable/Emit/CommonPEModuleBuilder.cs
+++ b/src/Compilers/Core/Portable/Emit/CommonPEModuleBuilder.cs
@@ -247,7 +247,7 @@ public uint GetFakeSymbolTokenForIL(Cci.IReference symbol, SyntaxNode syntaxNode
             uint token = _referencesInILMap.GetOrAddTokenFor(symbol, out added);
             if (added)
             {
-                ReferenceDependencyWalker.VisitReference(symbol, new EmitContext(this, syntaxNode, diagnostics, metadataOnly: false, includePrivateMembers: true)); // PROTOTYPE(refout) Not sure about this
+                ReferenceDependencyWalker.VisitReference(symbol, new EmitContext(this, syntaxNode, diagnostics, metadataOnly: false, includePrivateMembers: true));
             }
             return token;
         }
diff --git a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
index 5f58fd2094c52..029a9e8b343a9 100644
--- a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
+++ b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
@@ -1203,6 +1203,10 @@ lVbRuntimePlus:
                 AddDiagnostic(diagnostics, ERRID.ERR_NoRefOutWhenRefOnly)
             End If
 
+            If (refOnly OrElse outputRefFileName IsNot Nothing) AndAlso metadataReferences.Any(Function(r) r.Properties.EmbedInteropTypes) Then
+                AddDiagnostic(diagnostics, ERRID.ERR_NoEmbeddedTypeWhenRefOutOrRefOnly)
+            End If
+
             If outputKind = OutputKind.NetModule AndAlso (refOnly OrElse outputRefFileName IsNot Nothing) Then
                 AddDiagnostic(diagnostics, ERRID.ERR_NoNetModuleOutputWhenRefOutOrRefOnly)
             End If
diff --git a/src/Compilers/VisualBasic/Portable/Errors/Errors.vb b/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
index 5303649b024cf..e1354d47b40bd 100644
--- a/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
+++ b/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
@@ -1733,6 +1733,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
         ERR_NoRefOutWhenRefOnly = 37300
         ERR_NoNetModuleOutputWhenRefOutOrRefOnly = 37301
+        ERR_NoEmbeddedTypeWhenRefOutOrRefOnly = 37302
 
         '// WARNINGS BEGIN HERE
         WRN_UseOfObsoleteSymbol2 = 40000
diff --git a/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb b/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb
index 50815e2e104e2..19140e975e4dd 100644
--- a/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb
+++ b/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb
@@ -8070,6 +8070,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
         
+        '''<summary>
+        '''  Looks up a localized string similar to Cannot embed types when using /refout or /refonly..
+        '''</summary>
+        Friend ReadOnly Property ERR_NoEmbeddedTypeWhenRefOutOrRefOnly() As String
+            Get
+                Return ResourceManager.GetString("ERR_NoEmbeddedTypeWhenRefOutOrRefOnly", resourceCulture)
+            End Get
+        End Property
+        
         '''<summary>
         '''  Looks up a localized string similar to Array bounds cannot appear in type specifiers..
         '''</summary>
diff --git a/src/Compilers/VisualBasic/Portable/VBResources.resx b/src/Compilers/VisualBasic/Portable/VBResources.resx
index d7239d6c732ba..aa0c8d2866e81 100644
--- a/src/Compilers/VisualBasic/Portable/VBResources.resx
+++ b/src/Compilers/VisualBasic/Portable/VBResources.resx
@@ -5471,6 +5471,9 @@
   <data name="ERR_NoRefOutWhenRefOnly" xml:space="preserve">
     <value>Do not use refout when using refonly.</value>
   </data>
+  <data name="ERR_NoEmbeddedTypeWhenRefOutOrRefOnly" xml:space="preserve">
+    <value>Cannot embed types when using /refout or /refonly.</value>
+  </data>
   <data name="ERR_NoNetModuleOutputWhenRefOutOrRefOnly" xml:space="preserve">
     <value>Cannot compile net modules when using /refout or /refonly.</value>
   </data>
diff --git a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
index c0aa1e3150f7d..0e3f43a3cdf81 100644
--- a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
+++ b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
@@ -2923,6 +2923,14 @@ print Goodbye, World"
             parsedArgs.Errors.Verify(
                 Diagnostic(ERRID.ERR_NoNetModuleOutputWhenRefOutOrRefOnly).WithLocation(1, 1))
 
+            parsedArgs = DefaultParse({"/refout:ref.dll", "/link:b", "a.vb"}, baseDirectory)
+            parsedArgs.Errors.Verify(
+                Diagnostic(ERRID.ERR_NoEmbeddedTypeWhenRefOutOrRefOnly).WithLocation(1, 1))
+
+            parsedArgs = DefaultParse({"/refonly", "/link:b", "a.vb"}, baseDirectory)
+            parsedArgs.Errors.Verify(
+                Diagnostic(ERRID.ERR_NoEmbeddedTypeWhenRefOutOrRefOnly).WithLocation(1, 1))
+
             parsedArgs = DefaultParse({"/refonly", "/target:module", "a.vb"}, baseDirectory)
             parsedArgs.Errors.Verify(
                 Diagnostic(ERRID.ERR_NoNetModuleOutputWhenRefOutOrRefOnly).WithLocation(1, 1))
@@ -8188,6 +8196,10 @@ Public Class C
     Public Shared Sub Main()
         System.Console.Write(""Hello"")
     End Sub
+    ''' <summary>Private method</summary>
+    Private Shared Sub PrivateMethod()
+        System.Console.Write(""Private"")
+    End Sub
 End Class")
 
             Dim outWriter = New StringWriter(CultureInfo.InvariantCulture)
@@ -8202,7 +8214,7 @@ End Class")
 
             MetadataReaderUtils.VerifyPEMetadata(exe,
                 {"TypeDefinition:<Module>", "TypeDefinition:C"},
-                {"MethodDefinition:Void Main()", "MethodDefinition:Void .ctor()"},
+                {"MethodDefinition:Void Main()", "MethodDefinition:Void .ctor()", "MethodDefinition:Void PrivateMethod()"},
                 {"CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "STAThreadAttribute"}
                 )
 
@@ -8222,6 +8234,9 @@ a
 <member name=""M:C.Main"">
  <summary>Main method</summary>
 </member>
+<member name=""M:C.PrivateMethod"">
+ <summary>Private method</summary>
+</member>
 </members>
 </doc>"
             Assert.Equal(expectedDoc, content.Trim())
@@ -8295,6 +8310,14 @@ outWriter.ToString().Trim())
     Public Shared Sub Main()
         Bad()
     End Sub
+    ''' <summary>Field</summary>
+    Private Dim field As Integer
+
+    ''' <summary>Field</summary>
+    Private Structure S
+        ''' <summary>Struct Field</summary>
+        Private Dim field As Integer
+    End Structure
 End Class")
 
             Dim outWriter = New StringWriter(CultureInfo.InvariantCulture)
@@ -8310,7 +8333,7 @@ End Class")
             ' The types and members that are included needs further refinement.
             ' See issue https://github.com/dotnet/roslyn/issues/17612
             MetadataReaderUtils.VerifyPEMetadata(refDll,
-                {"TypeDefinition:<Module>", "TypeDefinition:C"},
+                {"TypeDefinition:<Module>", "TypeDefinition:C", "TypeDefinition:S"},
                 {"MethodDefinition:Void Main()", "MethodDefinition:Void .ctor()"},
                 {"CompilationRelaxationsAttribute", "RuntimeCompatibilityAttribute", "DebuggableAttribute", "STAThreadAttribute", "ReferenceAssemblyAttribute"}
                 )
@@ -8334,6 +8357,15 @@ a
 <member name=""M:C.Main"">
  <summary>Main method</summary>
 </member>
+<member name=""F:C.field"">
+ <summary>Field</summary>
+</member>
+<member name=""T:C.S"">
+ <summary>Field</summary>
+</member>
+<member name=""F:C.S.field"">
+ <summary>Struct Field</summary>
+</member>
 </members>
 </doc>"
             Assert.Equal(expectedDoc, content.Trim())
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
index f79bc3827226a..a2939a18115fa 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
@@ -886,6 +886,24 @@ End Class"
             End Using
         End Sub
 
+        <Fact>
+        Public Sub RefAssembly_DisallowEmbeddingTypes()
+            Dim comp = CreateCompilation("", references:={MscorlibRef.WithEmbedInteropTypes(True)},
+                            options:=TestOptions.DebugDll)
+
+            Using output As New MemoryStream()
+                Assert.Throws(Of ArgumentException)(Function() comp.Emit(output,
+                                    options:=EmitOptions.Default.WithEmitMetadataOnly(True).WithIncludePrivateMembers(False)))
+            End Using
+
+            Using output As New MemoryStream()
+                Using metadataOutput = New MemoryStream()
+                    Assert.Throws(Of ArgumentException)(Function() comp.Emit(output, metadataPEStream:=metadataOutput,
+                                        options:=EmitOptions.Default.WithIncludePrivateMembers(False)))
+                End Using
+            End Using
+        End Sub
+
         <Fact>
         Public Sub EmitMetadataOnly_DisallowMetadataPeStream()
             Dim comp = CreateCompilation("", references:={MscorlibRef},

From a68da9dbf8fb5cebb7461a271cf6c32d28261cec Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Tue, 9 May 2017 02:32:45 -0700
Subject: [PATCH 064/284] follow PR feedbacks

---
 ...cIncrementalAnalyzer.CompilationManager.cs |  2 +-
 .../Diagnostics/WorkspaceAnalyzerOptions.cs   | 21 ++++++++++---------
 .../Portable/Workspace/Solution/Document.cs   |  4 ++--
 .../Core/Diagnostics/DiagnosticComputer.cs    |  2 +-
 4 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs
index 1d1e41a0ad5f0..a446155b3d447 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.CompilationManager.cs
@@ -118,7 +118,7 @@ private CompilationWithAnalyzersOptions GetAnalyzerOptions(
                 // in IDE, we always set concurrentAnalysis == false otherwise, we can get into thread starvation due to
                 // async being used with syncronous blocking concurrency.
                 return new CompilationWithAnalyzersOptions(
-                    options: new WorkspaceAnalyzerOptions(project.AnalyzerOptions, project.Solution.Options, project.Solution.Workspace),
+                    options: new WorkspaceAnalyzerOptions(project.AnalyzerOptions, project.Solution.Options, project.Solution),
                     onAnalyzerException: GetOnAnalyzerException(project.Id),
                     analyzerExceptionFilter: GetAnalyzerExceptionFilter(project),
                     concurrentAnalysis: false,
diff --git a/src/Features/Core/Portable/Diagnostics/WorkspaceAnalyzerOptions.cs b/src/Features/Core/Portable/Diagnostics/WorkspaceAnalyzerOptions.cs
index 6bcc2c4d4e32e..483d78af05671 100644
--- a/src/Features/Core/Portable/Diagnostics/WorkspaceAnalyzerOptions.cs
+++ b/src/Features/Core/Portable/Diagnostics/WorkspaceAnalyzerOptions.cs
@@ -14,34 +14,33 @@ namespace Microsoft.CodeAnalysis.Diagnostics
     /// </summary>
     internal sealed class WorkspaceAnalyzerOptions : AnalyzerOptions
     {
-        private readonly Workspace _workspace;
+        private readonly Solution _solution;
         private readonly OptionSet _optionSet;
 
-        public WorkspaceAnalyzerOptions(AnalyzerOptions options, OptionSet optionSet, Workspace workspace)
+        public WorkspaceAnalyzerOptions(AnalyzerOptions options, OptionSet optionSet, Solution solution)
             : base(options.AdditionalFiles)
         {
-            _workspace = workspace;
+            _solution = solution;
             _optionSet = optionSet;
         }
 
-        public HostWorkspaceServices Services => _workspace.Services;
+        public HostWorkspaceServices Services => _solution.Workspace.Services;
 
         public async Task<OptionSet> GetDocumentOptionSetAsync(SyntaxTree syntaxTree, CancellationToken cancellationToken)
         {
-            var documentId = _workspace.CurrentSolution.GetDocumentId(syntaxTree);
+            var documentId = _solution.GetDocumentId(syntaxTree);
             if (documentId == null)
             {
                 return _optionSet;
             }
 
-            var document = _workspace.CurrentSolution.GetDocument(documentId);
+            var document = _solution.GetDocument(documentId);
             if (document == null)
             {
                 return _optionSet;
             }
 
-            var documentOptionSet = await document.GetOptionsAsync(_optionSet, cancellationToken).ConfigureAwait(false);
-            return documentOptionSet ?? _optionSet;
+            return await document.GetOptionsAsync(_optionSet, cancellationToken).ConfigureAwait(false);
         }
 
         public override bool Equals(object obj)
@@ -53,13 +52,15 @@ public override bool Equals(object obj)
 
             var other = obj as WorkspaceAnalyzerOptions;
             return other != null &&
-                _workspace == other._workspace &&
+                _solution.WorkspaceVersion == other._solution.WorkspaceVersion &&
+                _solution.Workspace == other._solution.Workspace &&
                 base.Equals(other);
         }
 
         public override int GetHashCode()
         {
-            return Hash.Combine(_workspace, base.GetHashCode());
+            return Hash.Combine(_solution.Workspace,
+                Hash.Combine(_solution.WorkspaceVersion, base.GetHashCode()));
         }
     }
 }
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
index 58360061cf39c..ce633d9b5b565 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
@@ -467,7 +467,7 @@ private string GetDebuggerDisplay()
             return GetOptionsAsync(Project.Solution.Options, cancellationToken);
         }
 
-        internal Task<DocumentOptionSet> GetOptionsAsync(OptionSet globalOptionSet, CancellationToken cancellationToken)
+        internal Task<DocumentOptionSet> GetOptionsAsync(OptionSet solutionOptions, CancellationToken cancellationToken)
         {
             // TODO: we have this workaround since Solution.Options is not actually snapshot but just return Workspace.Options which violate snapshot model.
             //       this doesn't validate whether same optionset is given to invalidate the cache or not. this is not new since existing implementation
@@ -478,7 +478,7 @@ internal Task<DocumentOptionSet> GetOptionsAsync(OptionSet globalOptionSet, Canc
                 var newAsyncLazy = new AsyncLazy<DocumentOptionSet>(async c =>
                 {
                     var optionsService = Project.Solution.Workspace.Services.GetRequiredService<IOptionService>();
-                    var documentOptionSet = await optionsService.GetUpdatedOptionSetForDocumentAsync(this, globalOptionSet, c).ConfigureAwait(false);
+                    var documentOptionSet = await optionsService.GetUpdatedOptionSetForDocumentAsync(this, solutionOptions, c).ConfigureAwait(false);
                     return new DocumentOptionSet(documentOptionSet, Project.Language);
                 }, cacheResult: true);
 
diff --git a/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs b/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs
index 6bc968139429d..9d53a7a5e49ec 100644
--- a/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs
+++ b/src/Workspaces/Remote/Core/Diagnostics/DiagnosticComputer.cs
@@ -75,7 +75,7 @@ private async Task<DiagnosticAnalysisResultMap<string, DiagnosticAnalysisResultB
             // TODO: can we support analyzerExceptionFilter in remote host? 
             //       right now, host doesn't support watson, we might try to use new NonFatal watson API?
             var analyzerOptions = new CompilationWithAnalyzersOptions(
-                    options: new WorkspaceAnalyzerOptions(_project.AnalyzerOptions, MergeOptions(_project.Solution.Options, options), temporaryWorksapce),
+                    options: new WorkspaceAnalyzerOptions(_project.AnalyzerOptions, MergeOptions(_project.Solution.Options, options), temporaryWorksapce.CurrentSolution),
                     onAnalyzerException: OnAnalyzerException,
                     analyzerExceptionFilter: null,
                     concurrentAnalysis: useConcurrent,

From 2bff739821ac58335ca809060e229a9330e5898e Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Tue, 9 May 2017 02:36:32 -0700
Subject: [PATCH 065/284] remove unused usings.

---
 .../RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs    | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs b/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs
index 3071ba2917d1b..2a85108a87d22 100644
--- a/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.SolutionChecksumUpdater.cs
@@ -8,7 +8,6 @@
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.SolutionCrawler;
 using Microsoft.CodeAnalysis.Internal.Log;
-using System.Diagnostics;
 
 namespace Microsoft.VisualStudio.LanguageServices.Remote
 {

From e4b4ea4ccdd93e7348b1803d5c60109854858d5f Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Tue, 9 May 2017 05:15:05 -0700
Subject: [PATCH 066/284] made document checksum not to use persistant service.

we found 2 issues. 1. hard to validate persisted data and 2. recalculating checksum is faster than reading from storage.
---
 .../Test.Next/Services/AssetServiceTests.cs   |   1 +
 .../Services/ServiceHubServicesTests.cs       |   1 +
 .../Services/SolutionServiceTests.cs          |   1 +
 .../Test.Next/VisualStudioTest.Next.csproj    |   1 -
 .../Core/Portable/Log/FunctionId.cs           |  71 ++++++----
 .../Solution/TextDocumentState_Checksum.cs    |  85 +-----------
 .../Remote/Core/RemoteWorkspaces.csproj       |   1 +
 .../Remote/Core/Services/SolutionCreator.cs   |  68 +++++++++-
 src/Workspaces/Remote/Core/TestUtils.cs       | 125 ++++++++++++++++++
 9 files changed, 238 insertions(+), 116 deletions(-)
 create mode 100644 src/Workspaces/Remote/Core/TestUtils.cs

diff --git a/src/VisualStudio/Core/Test.Next/Services/AssetServiceTests.cs b/src/VisualStudio/Core/Test.Next/Services/AssetServiceTests.cs
index 85dec43674b29..e9e949f0946b6 100644
--- a/src/VisualStudio/Core/Test.Next/Services/AssetServiceTests.cs
+++ b/src/VisualStudio/Core/Test.Next/Services/AssetServiceTests.cs
@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Remote;
+using Microsoft.CodeAnalysis.Remote.DebugUtil;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Roslyn.VisualStudio.Next.UnitTests.Mocks;
diff --git a/src/VisualStudio/Core/Test.Next/Services/ServiceHubServicesTests.cs b/src/VisualStudio/Core/Test.Next/Services/ServiceHubServicesTests.cs
index ca558d84ed835..94df904ea4f90 100644
--- a/src/VisualStudio/Core/Test.Next/Services/ServiceHubServicesTests.cs
+++ b/src/VisualStudio/Core/Test.Next/Services/ServiceHubServicesTests.cs
@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Remote;
+using Microsoft.CodeAnalysis.Remote.DebugUtil;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.TodoComments;
 using Roslyn.Test.Utilities;
diff --git a/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs b/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
index 69aebcfb19175..5c667179a4681 100644
--- a/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
+++ b/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Remote;
+using Microsoft.CodeAnalysis.Remote.DebugUtil;
 using Microsoft.CodeAnalysis.SolutionCrawler;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.LanguageServices.Remote;
diff --git a/src/VisualStudio/Core/Test.Next/VisualStudioTest.Next.csproj b/src/VisualStudio/Core/Test.Next/VisualStudioTest.Next.csproj
index 6cb0c1dfabd0c..b076f92a0ab82 100644
--- a/src/VisualStudio/Core/Test.Next/VisualStudioTest.Next.csproj
+++ b/src/VisualStudio/Core/Test.Next/VisualStudioTest.Next.csproj
@@ -263,7 +263,6 @@
     <Compile Include="Mocks\TestOptionSet.cs" />
     <Compile Include="Remote\JsonConverterTests.cs" />
     <Compile Include="Remote\RemoteHostClientServiceFactoryTests.cs" />
-    <Compile Include="TestUtils.cs" />
     <Compile Include="Services\SolutionServiceTests.cs" />
     <Compile Include="Services\AssetStorageTests.cs" />
     <Compile Include="Services\AssetServiceTests.cs" />
diff --git a/src/Workspaces/Core/Portable/Log/FunctionId.cs b/src/Workspaces/Core/Portable/Log/FunctionId.cs
index 608bc297dbe10..2ea627eba7b32 100644
--- a/src/Workspaces/Core/Portable/Log/FunctionId.cs
+++ b/src/Workspaces/Core/Portable/Log/FunctionId.cs
@@ -327,50 +327,69 @@ internal enum FunctionId
         BKTree_ExceptionInCacheRead,
         IntellisenseBuild_Failed,
 
+        FileTextLoader_FileLengthThresholdExceeded,
+
         // Generic performance measurement action IDs
         MeasurePerformance_StartAction,
         MeasurePerformance_StopAction,
 
-        RemoteHostClientService_AddGlobalAssetsAsync,
-        RemoteHostClientService_RemoveGlobalAssets,
-        RemoteHostClientService_Enabled,
-        ServiceHubRemoteHostClient_CreateAsync,
-        SolutionSynchronizationServiceFactory_CreatePinnedRemotableDataScopeAsync,
-        PinnedRemotableDataScope_GetRemotableData,
         Serializer_CreateChecksum,
         Serializer_Serialize,
         Serializer_Deserialize,
+
         CodeAnalysisService_CalculateDiagnosticsAsync,
         CodeAnalysisService_SerializeDiagnosticResultAsync,
-        AssetStorage_CleanAssets,
-        AssetService_GetAssetAsync,
-        SnapshotService_RequestAssetAsync,
-        CompilationService_GetCompilationAsync,
-        RemoteHostService_SynchronizePrimaryWorkspaceAsync,
-        RemoteHostService_SynchronizeGlobalAssetsAsync,
-        AssetStorage_TryGetAsset,
-        AssetService_SynchronizeAssetsAsync,
-        AssetService_SynchronizeSolutionAssetsAsync,
         CodeAnalysisService_GetReferenceCountAsync,
         CodeAnalysisService_FindReferenceLocationsAsync,
         CodeAnalysisService_FindReferenceMethodsAsync,
         CodeAnalysisService_GetFullyQualifiedName,
-        SolutionChecksumUpdater_SynchronizePrimaryWorkspace,
-        SolutionState_ComputeChecksumsAsync,
-        ProjectState_ComputeChecksumsAsync,
-        DocumentState_ComputeChecksumsAsync,
-        JsonRpcSession_RequestAssetAsync,
-        SolutionSynchronizationService_GetRemotableData,
-        AssetService_SynchronizeProjectAssetsAsync,
-        FileTextLoader_FileLengthThresholdExceeded,
+        CodeAnalysisService_GetTodoCommentsAsync,
+        CodeAnalysisService_GetDesignerAttributesAsync,
+
+        ServiceHubRemoteHostClient_CreateAsync,
+        PinnedRemotableDataScope_GetRemotableData,
+
         RemoteHost_Connect,
         RemoteHost_Disconnect,
-        CodeAnalysisService_GetTodoCommentsAsync,
+
+        RemoteHostClientService_AddGlobalAssetsAsync,
+        RemoteHostClientService_RemoveGlobalAssets,
+        RemoteHostClientService_Enabled,
+        RemoteHostClientService_Restarted,
+
+        RemoteHostService_SynchronizePrimaryWorkspaceAsync,
+        RemoteHostService_SynchronizeGlobalAssetsAsync,
+
+        AssetStorage_CleanAssets,
+        AssetStorage_TryGetAsset,
+
+        AssetService_GetAssetAsync,
+        AssetService_SynchronizeAssetsAsync,
+        AssetService_SynchronizeSolutionAssetsAsync,
+        AssetService_SynchronizeProjectAssetsAsync,
+
         CodeLens_GetReferenceCountAsync,
         CodeLens_FindReferenceLocationsAsync,
         CodeLens_FindReferenceMethodsAsync,
         CodeLens_GetFullyQualifiedName,
-        RemoteHostClientService_Restarted,
-        CodeAnalysisService_GetDesignerAttributesAsync,
+
+        SolutionState_ComputeChecksumsAsync,
+        ProjectState_ComputeChecksumsAsync,
+        DocumentState_ComputeChecksumsAsync,
+
+        SolutionSynchronizationService_GetRemotableData,
+        SolutionSynchronizationServiceFactory_CreatePinnedRemotableDataScopeAsync,
+
+        SolutionChecksumUpdater_SynchronizePrimaryWorkspace,
+
+        JsonRpcSession_RequestAssetAsync,
+
+        SolutionService_GetSolutionAsync,
+        SolutionService_UpdatePrimaryWorkspaceAsync,
+
+        SnapshotService_RequestAssetAsync,
+
+        CompilationService_GetCompilationAsync,
+        SolutionCreator_AssetDifferences,
     }
 }
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentState_Checksum.cs
index 99f6b6e840625..7caf67306c022 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentState_Checksum.cs
@@ -1,22 +1,14 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Serialization;
-using Microsoft.CodeAnalysis.Shared.Utilities;
-using Microsoft.CodeAnalysis.Versions;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis
 {
     internal partial class TextDocumentState
     {
-        private const string TextChecksum = nameof(TextChecksum);
-        private const string SerializationFormat = "1";
-
         public bool TryGetStateChecksums(out DocumentStateChecksums stateChecksums)
         {
             return _lazyChecksums.TryGetValue(out stateChecksums);
@@ -42,85 +34,10 @@ private async Task<DocumentStateChecksums> ComputeChecksumsAsync(CancellationTok
                 var serializer = new Serializer(solutionServices.Workspace);
 
                 var infoChecksum = serializer.CreateChecksum(Info.Attributes, cancellationToken);
-                var textChecksum = await GetTextChecksumAsync(serializer, await textAndVersionTask.ConfigureAwait(false), cancellationToken).ConfigureAwait(false);
+                var textChecksum = serializer.CreateChecksum((await textAndVersionTask.ConfigureAwait(false)).Text, cancellationToken);
 
                 return new DocumentStateChecksums(infoChecksum, textChecksum);
             }
         }
-
-        private async Task<Checksum> GetTextChecksumAsync(Serializer serializer, TextAndVersion textAndVersion, CancellationToken cancellationToken)
-        {
-            // calculating checksum for source text is one of most expansive checksum calculation we need to do.
-            // this should let us get around it if possible
-            var solution = solutionServices.Workspace.CurrentSolution;
-
-            var document = solution.GetDocument(Id);
-            if (document == null)
-            {
-                // can't use persistent service since it is based on solution objects
-                return serializer.CreateChecksum(textAndVersion.Text, cancellationToken);
-            }
-
-            var storage = solution.Workspace.Services.GetService<IPersistentStorageService>()?.GetStorage(solution);
-            if (storage == null)
-            {
-                // persistent service not available
-                return serializer.CreateChecksum(textAndVersion.Text, cancellationToken);
-            }
-
-            try
-            {
-                using (var stream = await storage.ReadStreamAsync(document, TextChecksum, cancellationToken).ConfigureAwait(false))
-                using (var reader = ObjectReader.TryGetReader(stream))
-                {
-                    if (TryReadVersion(reader, out var persistedVersion) &&
-                        document.CanReusePersistedTextVersion(textAndVersion.Version, persistedVersion))
-                    {
-                        return Checksum.ReadFrom(reader);
-                    }
-                }
-
-                // either checksum doesn't exist or can't reuse. re-calculate the checksum
-                var checksum = serializer.CreateChecksum(textAndVersion.Text, cancellationToken);
-
-                // save newly calculated checksum
-                using (var stream = SerializableBytes.CreateWritableStream())
-                using (var writer = new ObjectWriter(stream, cancellationToken))
-                {
-                    WriteVersionsTo(writer, textAndVersion.Version);
-                    checksum.WriteTo(writer);
-
-                    stream.Position = 0;
-                    await storage.WriteStreamAsync(document, TextChecksum, stream, cancellationToken).ConfigureAwait(false);
-                }
-
-                return checksum;
-            }
-            catch (Exception e) when (IOUtilities.IsNormalIOException(e))
-            {
-                // Storage APIs can throw arbitrary exceptions.
-            }
-
-            // go simple route if persistent thing didn't work out
-            return serializer.CreateChecksum(textAndVersion.Text, cancellationToken);
-        }
-
-        private void WriteVersionsTo(ObjectWriter writer, VersionStamp version)
-        {
-            writer.WriteString(SerializationFormat);
-            version.WriteTo(writer); ;
-        }
-
-        private static bool TryReadVersion(ObjectReader reader, out VersionStamp persistedVersion)
-        {
-            persistedVersion = VersionStamp.Default;
-            if (reader?.ReadString() != SerializationFormat)
-            {
-                return false;
-            }
-
-            persistedVersion = VersionStamp.ReadFrom(reader);
-            return true;
-        }
     }
 }
diff --git a/src/Workspaces/Remote/Core/RemoteWorkspaces.csproj b/src/Workspaces/Remote/Core/RemoteWorkspaces.csproj
index 4f6971b6f9ae3..3790331862d61 100644
--- a/src/Workspaces/Remote/Core/RemoteWorkspaces.csproj
+++ b/src/Workspaces/Remote/Core/RemoteWorkspaces.csproj
@@ -78,6 +78,7 @@
     <Compile Include="Services\TemporaryWorkspace.cs" />
     <Compile Include="Services\TemporaryWorkspaceOptionsServiceFactory.cs" />
     <Compile Include="Storage\RemotePersistentStorageLocationService.cs" />
+    <Compile Include="TestUtils.cs" />
   </ItemGroup>
   <Import Project="..\..\..\..\build\Targets\Imports.targets" />
 </Project>
\ No newline at end of file
diff --git a/src/Workspaces/Remote/Core/Services/SolutionCreator.cs b/src/Workspaces/Remote/Core/Services/SolutionCreator.cs
index ab44bd54b1567..a785663ffafeb 100644
--- a/src/Workspaces/Remote/Core/Services/SolutionCreator.cs
+++ b/src/Workspaces/Remote/Core/Services/SolutionCreator.cs
@@ -1,15 +1,16 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.IO;
 using System.Linq;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Serialization;
 using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.Remote.DebugUtil;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Remote
@@ -79,10 +80,8 @@ public async Task<Solution> CreateSolutionAsync(Checksum newSolutionChecksum)
                 solution = await UpdateProjectsAsync(solution, oldSolutionChecksums.Projects, newSolutionChecksums.Projects).ConfigureAwait(false);
             }
 
-#if DEBUG
             // make sure created solution has same checksum as given one
-            Contract.Requires(newSolutionChecksum == await solution.State.GetChecksumAsync(_cancellationToken).ConfigureAwait(false));
-#endif
+            await ValidateChecksumAsync(newSolutionChecksum, solution).ConfigureAwait(false);
 
             return solution;
         }
@@ -613,5 +612,64 @@ private ImmutableArray<string> GetStrongNameKeyPaths(ProjectInfo.ProjectAttribut
 
             return builder.ToImmutableAndFree();
         }
+
+        private async Task ValidateChecksumAsync(Checksum givenSolutionChecksum, Solution solution)
+        {
+            // have this to avoid error on async
+            await SpecializedTasks.EmptyTask;
+
+#if DEBUG
+            var currentSolutionChecksum = await solution.State.GetChecksumAsync(_cancellationToken).ConfigureAwait(false);
+
+            if (givenSolutionChecksum == currentSolutionChecksum)
+            {
+                return;
+            }
+
+            Contract.Requires(false, "checksum not same");
+
+            var map = solution.GetAssetMap();
+            await RemoveDuplicateChecksumsAsync(givenSolutionChecksum, map).ConfigureAwait(false);
+
+            foreach (var kv in map.Where(kv => kv.Value is ChecksumWithChildren).ToList())
+            {
+                map.Remove(kv.Key);
+            }
+
+            var sb = new StringBuilder();
+            foreach (var kv in map)
+            {
+                sb.AppendLine($"{kv.Key.ToString()}, {kv.Value.ToString()}");
+            }
+
+            Logger.Log(FunctionId.SolutionCreator_AssetDifferences, sb.ToString());
+#endif
+
+            return;
+        }
+
+        private async Task RemoveDuplicateChecksumsAsync(Checksum givenSolutionChecksum, Dictionary<Checksum, object> map)
+        {
+            var solutionChecksums = await _assetService.GetAssetAsync<SolutionStateChecksums>(givenSolutionChecksum, _cancellationToken).ConfigureAwait(false);
+            map.RemoveChecksums(solutionChecksums);
+
+            foreach (var projectChecksum in solutionChecksums.Projects)
+            {
+                var projectChecksums = await _assetService.GetAssetAsync<ProjectStateChecksums>(projectChecksum, _cancellationToken).ConfigureAwait(false);
+                map.RemoveChecksums(projectChecksums);
+
+                foreach (var documentChecksum in projectChecksums.Documents)
+                {
+                    var documentChecksums = await _assetService.GetAssetAsync<DocumentStateChecksums>(documentChecksum, _cancellationToken).ConfigureAwait(false);
+                    map.RemoveChecksums(documentChecksums);
+                }
+
+                foreach (var documentChecksum in projectChecksums.AdditionalDocuments)
+                {
+                    var documentChecksums = await _assetService.GetAssetAsync<DocumentStateChecksums>(documentChecksum, _cancellationToken).ConfigureAwait(false);
+                    map.RemoveChecksums(documentChecksums);
+                }
+            }
+        }
     }
 }
diff --git a/src/Workspaces/Remote/Core/TestUtils.cs b/src/Workspaces/Remote/Core/TestUtils.cs
new file mode 100644
index 0000000000000..8010164270c98
--- /dev/null
+++ b/src/Workspaces/Remote/Core/TestUtils.cs
@@ -0,0 +1,125 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Threading;
+using Microsoft.CodeAnalysis.Serialization;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.Remote.DebugUtil
+{
+    internal static class TestUtils
+    {
+        public static void RemoveChecksums(this Dictionary<Checksum, object> map, ChecksumWithChildren checksums)
+        {
+            map.Remove(checksums.Checksum);
+
+            foreach (var child in checksums.Children)
+            {
+                var checksum = child as Checksum;
+                if (checksum != null)
+                {
+                    map.Remove(checksum);
+                }
+
+                var collection = child as ChecksumCollection;
+                if (collection != null)
+                {
+                    foreach (var item in collection)
+                    {
+                        map.Remove(item);
+                    }
+                }
+            }
+        }
+
+        public static Dictionary<Checksum, object> GetAssetMap(this Solution solution)
+        {
+            var map = new Dictionary<Checksum, object>();
+
+            AppendAssetMap(solution, map);
+
+            return map;
+        }
+
+        public static Dictionary<Checksum, object> GetAssetMap(this Project project)
+        {
+            var map = new Dictionary<Checksum, object>();
+
+            AppendAssetMap(project, map);
+
+            return map;
+        }
+
+        public static void AppendAssetMap(this Solution solution, Dictionary<Checksum, object> map)
+        {
+            SolutionStateChecksums solutionChecksums;
+            Contract.Requires(solution.State.TryGetStateChecksums(out solutionChecksums));
+
+            solutionChecksums.Find(solution.State, Flatten(solutionChecksums), map, CancellationToken.None);
+
+            foreach (var project in solution.Projects)
+            {
+                AppendAssetMap(project, map);
+            }
+        }
+
+        private static void AppendAssetMap(Project project, Dictionary<Checksum, object> map)
+        {
+            ProjectStateChecksums projectChecksums;
+            if (!project.State.TryGetStateChecksums(out projectChecksums))
+            {
+                Contract.Requires(!RemoteSupportedLanguages.IsSupported(project.Language));
+                return;
+            }
+
+            projectChecksums.Find(project.State, Flatten(projectChecksums), map, CancellationToken.None);
+
+            foreach (var document in project.Documents)
+            {
+                AppendAssetMap(document, map);
+            }
+
+            foreach (var document in project.AdditionalDocuments)
+            {
+                AppendAssetMap(document, map);
+            }
+        }
+
+        private static void AppendAssetMap(TextDocument document, Dictionary<Checksum, object> map)
+        {
+            DocumentStateChecksums documentChecksums;
+            Contract.Requires(document.State.TryGetStateChecksums(out documentChecksums));
+
+            documentChecksums.Find(document.State, Flatten(documentChecksums), map, CancellationToken.None);
+
+            // fix up due to source text can't be obtained synchronously in product code
+            map[documentChecksums.Text] = document.State.GetTextSynchronously(CancellationToken.None);
+        }
+
+        private static HashSet<Checksum> Flatten(ChecksumWithChildren checksums)
+        {
+            var set = new HashSet<Checksum>();
+            set.Add(checksums.Checksum);
+
+            foreach (var child in checksums.Children)
+            {
+                var checksum = child as Checksum;
+                if (checksum != null)
+                {
+                    set.Add(checksum);
+                }
+
+                var collection = child as ChecksumCollection;
+                if (collection != null)
+                {
+                    foreach (var item in collection)
+                    {
+                        set.Add(item);
+                    }
+                }
+            }
+
+            return set;
+        }
+    }
+}

From d0490d7c86c43fa72afad2bfd476d6a1e30530f9 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Tue, 9 May 2017 06:15:03 -0700
Subject: [PATCH 067/284] fix test failures

---
 .../Remote/InProcRemostHostClient.cs          |  2 +-
 .../Services/SolutionServiceTests.cs          | 28 ++++++++++++-------
 2 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/src/EditorFeatures/TestUtilities/Remote/InProcRemostHostClient.cs b/src/EditorFeatures/TestUtilities/Remote/InProcRemostHostClient.cs
index c185f1bfa2788..3d20c8ed0c12f 100644
--- a/src/EditorFeatures/TestUtilities/Remote/InProcRemostHostClient.cs
+++ b/src/EditorFeatures/TestUtilities/Remote/InProcRemostHostClient.cs
@@ -65,7 +65,7 @@ protected override async Task<Session> TryCreateServiceSessionAsync(string servi
             // this is the back channel the system uses to move data between VS and remote host
             var snapshotStream = getSnapshotAsync.Value == null ? null : await _inprocServices.RequestServiceAsync(WellKnownServiceHubServices.SnapshotService, cancellationToken).ConfigureAwait(false);
 
-            // get stream from service hub to communicate service specific information
+            // get stream from service hub to communicate service specific information 
             // this is what consumer actually use to communicate information
             var serviceStream = await _inprocServices.RequestServiceAsync(serviceName, cancellationToken).ConfigureAwait(false);
 
diff --git a/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs b/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
index 66c465789996c..0d5aaf3a39ad7 100644
--- a/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
+++ b/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
@@ -40,22 +40,30 @@ public async Task TestCreation()
         [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
         public async Task TestGetSolutionWithPrimaryFlag()
         {
-            var code = @"class Test { void Method() { } }";
+            var code1 = @"class Test1 { void Method() { } }";
 
-            using (var workspace = TestWorkspace.CreateCSharp(code))
+            using (var workspace = TestWorkspace.CreateCSharp(code1))
             {
                 var solution = workspace.CurrentSolution;
                 var solutionChecksum = await solution.State.GetChecksumAsync(CancellationToken.None);
 
-                var service1 = await GetSolutionServiceAsync(solution);
-                var synched1 = await service1.GetSolutionAsync(solutionChecksum, CancellationToken.None);
-                Assert.Equal(solutionChecksum, await synched1.State.GetChecksumAsync(CancellationToken.None));
-                Assert.True(synched1.Workspace is TemporaryWorkspace);
+                var service = await GetSolutionServiceAsync(solution);
+                var synched = await service.GetSolutionAsync(solutionChecksum, CancellationToken.None);
+                Assert.Equal(solutionChecksum, await synched.State.GetChecksumAsync(CancellationToken.None));
+                Assert.True(synched.Workspace is TemporaryWorkspace);
+            }
+
+            var code2 = @"class Test2 { void Method() { } }";
 
-                var service2 = await GetSolutionServiceAsync(solution);
-                var synched2 = await service2.GetSolutionAsync(solutionChecksum, primary: true, cancellationToken: CancellationToken.None);
-                Assert.Equal(solutionChecksum, await synched2.State.GetChecksumAsync(CancellationToken.None));
-                Assert.True(synched2.Workspace is RemoteWorkspace);
+            using (var workspace = TestWorkspace.CreateCSharp(code2))
+            {
+                var solution = workspace.CurrentSolution;
+                var solutionChecksum = await solution.State.GetChecksumAsync(CancellationToken.None);
+
+                var service = await GetSolutionServiceAsync(solution);
+                var synched = await service.GetSolutionAsync(solutionChecksum, primary: true, cancellationToken: CancellationToken.None);
+                Assert.Equal(solutionChecksum, await synched.State.GetChecksumAsync(CancellationToken.None));
+                Assert.True(synched.Workspace is RemoteWorkspace);
             }
         }
 

From ddd68b6e04dfd1d936b4b01aafac700041f3cea8 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Tue, 9 May 2017 10:04:15 -0700
Subject: [PATCH 068/284] fix test failure

---
 src/VisualStudio/Core/Next/Remote/JsonRpcSession.cs |  2 +-
 .../Remote/ServiceHub/Shared/RoslynJsonConverter.cs | 13 +++++++++----
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/VisualStudio/Core/Next/Remote/JsonRpcSession.cs b/src/VisualStudio/Core/Next/Remote/JsonRpcSession.cs
index 1144f558da455..5ce8f5f5472f7 100644
--- a/src/VisualStudio/Core/Next/Remote/JsonRpcSession.cs
+++ b/src/VisualStudio/Core/Next/Remote/JsonRpcSession.cs
@@ -92,7 +92,7 @@ private async Task InitializeAsync()
                 await _snapshotClientOpt.InvokeAsync(WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, _currentSessionId, PinnedScopeOpt.Primary, PinnedScopeOpt.SolutionChecksum).ConfigureAwait(false);
             }
 
-            await _serviceClient.InvokeAsync(WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, _currentSessionId, PinnedScopeOpt?.Primary, PinnedScopeOpt?.SolutionChecksum).ConfigureAwait(false);
+            await _serviceClient.InvokeAsync(WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, _currentSessionId, PinnedScopeOpt?.Primary ?? false, PinnedScopeOpt?.SolutionChecksum).ConfigureAwait(false);
         }
 
         public override Task InvokeAsync(string targetName, params object[] arguments)
diff --git a/src/Workspaces/Remote/ServiceHub/Shared/RoslynJsonConverter.cs b/src/Workspaces/Remote/ServiceHub/Shared/RoslynJsonConverter.cs
index 372cc037f2766..a0478e654bbb7 100644
--- a/src/Workspaces/Remote/ServiceHub/Shared/RoslynJsonConverter.cs
+++ b/src/Workspaces/Remote/ServiceHub/Shared/RoslynJsonConverter.cs
@@ -127,11 +127,16 @@ private class ChecksumJsonConverter : JsonConverter
         {
             public override bool CanConvert(Type objectType) => typeof(Checksum) == objectType;
 
-            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) =>
-                new Checksum(Convert.FromBase64String((string)reader.Value));
+            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+            {
+                var value = (string)reader.Value;
+                return value == null ? null : new Checksum(Convert.FromBase64String(value));
+            }
 
-            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) =>
-                writer.WriteValue(value.ToString());
+            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+            {
+                writer.WriteValue(value?.ToString());
+            }
         }
     }
 }

From 3986cdb6c061ecc79680967e1a7757e64b6888f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Matou=C5=A1ek?=
 <tmat@users.noreply.github.com>
Date: Tue, 9 May 2017 10:39:27 -0700
Subject: [PATCH 069/284] Implement SourceLink for Windows PDBs (#18539)

---
 docs/compilers/CSharp/CommandLine.md          |   6 +-
 docs/compilers/Visual Basic/CommandLine.md    |   7 +-
 .../Portable/CSharpResources.Designer.cs      |   6 +-
 .../CSharp/Portable/CSharpResources.resx      |   6 +-
 .../CommandLine/CSharpCommandLineParser.cs    |   7 +-
 .../CSharp/Portable/Errors/ErrorCode.cs       |   2 +-
 .../Test/CommandLine/CommandLineTests.cs      |  46 ++++--
 .../Test/Emit/CSharpCompilerEmitTest.csproj   |   1 +
 .../Test/Emit/PDB/PDBSourceLinkTests.cs       | 153 ++++++++++++++++++
 .../Symbol/Compilation/CompilationAPITests.cs |  12 --
 .../StreamExtensionsTests.cs                  |  43 ++++-
 .../CodeAnalysisResources.Designer.cs         |  18 +--
 .../Core/Portable/CodeAnalysisResources.resx  |   6 +-
 .../Core/Portable/Compilation/Compilation.cs  |  16 +-
 .../InternalUtilities/StreamExtensions.cs     |  25 +++
 .../NativePdbWriter/ISymUnmanagedWriter.cs    |   9 +-
 .../Portable/NativePdbWriter/PdbWriter.cs     |  37 ++++-
 .../PEWriter/MetadataWriter.PortablePdb.cs    |   8 +-
 .../Core/Portable/PEWriter/PeWriter.cs        |   5 +
 .../VisualBasicCommandLineParser.vb           |   6 +-
 .../VisualBasic/Portable/Errors/Errors.vb     |   2 +-
 .../Portable/VBResources.Designer.vb          |   6 +-
 .../VisualBasic/Portable/VBResources.resx     |   6 +-
 .../Test/CommandLine/CommandLineTests.vb      |  18 ++-
 .../Compilation/CompilationAPITests.vb        |  12 --
 src/Test/PdbUtilities/Pdb/SymReaderFactory.cs |  20 +--
 .../Utilities/Portable/Pdb/PdbValidation.cs   |  29 +++-
 27 files changed, 393 insertions(+), 119 deletions(-)
 create mode 100644 src/Compilers/CSharp/Test/Emit/PDB/PDBSourceLinkTests.cs

diff --git a/docs/compilers/CSharp/CommandLine.md b/docs/compilers/CSharp/CommandLine.md
index 8244ce7bfc71e..6af4c2f7ea19d 100644
--- a/docs/compilers/CSharp/CommandLine.md
+++ b/docs/compilers/CSharp/CommandLine.md
@@ -29,7 +29,11 @@
 | `/linkresource`:*resinfo* | Link the specified resource to this assembly (Short form: `/linkres`) Where the *resinfo* format  is *file*{`,`*string name*{`,``public``|``private`}}
 | **CODE GENERATION**
 | `/debug`{`+`&#124;`-`} | Emit (or do not Emit) debugging information
-| `/debug`:{`full`&#124;`pdbonly`&#124;`portable`} | Specify debugging type (`full` is default, and  enables attaching a debugger to a running program. `portable` is a cross-platform format)
+| `/debug`:`full` | Emit debugging information to .pdb file using default format for the current platform: _Windows PDB_ on Windows, _Portable PDB_ on other systems
+| `/debug`:`pdbonly` | Same as `/debug:full`. For backward compatibility. 
+| `/debug`:`portable` | Emit debugging information to to .pdb file using cross-platform [Portable PDB format](https://github.com/dotnet/core/blob/master/Documentation/diagnostics/portable_pdb.md)
+| `/debug`:`embedded` | Emit debugging information into the .dll/.exe itself (.pdb file is not produced) using [Portable PDB format](https://github.com/dotnet/core/blob/master/Documentation/diagnostics/portable_pdb.md).
+| `/sourcelink`:*file* | [Source link](https://github.com/dotnet/core/blob/master/Documentation/diagnostics/source_link.md) info to embed into PDB.
 | `/optimize`{`+`&#124;`-`} | Enable optimizations (Short form: `/o`)
 | `/deterministic` | Produce a deterministic assembly (including module version GUID and timestamp)
 | **ERRORS AND WARNINGS**
diff --git a/docs/compilers/Visual Basic/CommandLine.md b/docs/compilers/Visual Basic/CommandLine.md
index 0a7afcefd67da..4c52e339fce47 100644
--- a/docs/compilers/Visual Basic/CommandLine.md	
+++ b/docs/compilers/Visual Basic/CommandLine.md	
@@ -27,9 +27,14 @@
 | `/win32manifest:`*file* | The provided file is embedded in the manifest section of the output PE.
 | `/win32resource:`*file* | Specifies a Win32 resource file (.res).
 | **CODE GENERATION**
+| `/debug`{`+`&#124;`-`} | Emit debugging information.
+| `/debug`:`full` | Emit debugging information to .pdb file using default format for the current platform: _Windows PDB_ on Windows, _Portable PDB_ on other systems
+| `/debug`:`pdbonly` | Same as `/debug:full`. For backward compatibility. 
+| `/debug`:`portable` | Emit debugging information to to .pdb file using cross-platform [Portable PDB format](https://github.com/dotnet/core/blob/master/Documentation/diagnostics/portable_pdb.md)
+| `/debug`:`embedded` | Emit debugging information into the .dll/.exe itself (.pdb file is not produced) using [Portable PDB format](https://github.com/dotnet/core/blob/master/Documentation/diagnostics/portable_pdb.md).
+| `/sourcelink`:*file* | [Source link](https://github.com/dotnet/core/blob/master/Documentation/diagnostics/source_link.md) info to embed into PDB.
 | `/optimize`{`+`&#124;`-`} | Enable optimizations.
 | `/removeintchecks`{`+`&#124;`-`} | Remove integer checks. Default off.
-| `/debug`{`+`&#124;`-`} | Emit debugging information.
 | `/debug:full` | Emit full debugging information (default).
 | `/debug:portable` | Emit debugging information in the portable format.
 | `/debug:pdbonly` | Emit PDB file only.
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
index 65d87f9cc8232..7a7b71a958a5d 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
+++ b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
@@ -8675,11 +8675,11 @@ internal static string ERR_SourceFileReferencesNotSupported {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to /sourcelink switch is only supported when emitting Portable PDB (/debug:portable or /debug:embedded must be specified)..
+        ///   Looks up a localized string similar to /sourcelink switch is only supported when emitting PDB..
         /// </summary>
-        internal static string ERR_SourceLinkRequiresPortablePdb {
+        internal static string ERR_SourceLinkRequiresPdb {
             get {
-                return ResourceManager.GetString("ERR_SourceLinkRequiresPortablePdb", resourceCulture);
+                return ResourceManager.GetString("ERR_SourceLinkRequiresPdb", resourceCulture);
             }
         }
         
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index 13a64ea0367ed..9009bd391d8fe 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -4450,7 +4450,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
                                (including module version GUID and timestamp)
  /instrument:TestCoverage      Produce an assembly instrumented to collect
                                coverage information
- /sourcelink:&lt;file&gt;            Source link info to embed into Portable PDB.
+ /sourcelink:&lt;file&gt;            Source link info to embed into PDB.
 
                         - ERRORS AND WARNINGS -
  /warnaserror[+|-]             Report all warnings as errors
@@ -4971,8 +4971,8 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_ExpressionTreeContainsTupleConversion" xml:space="preserve">
     <value>An expression tree may not contain a tuple conversion.</value>
   </data>
-  <data name="ERR_SourceLinkRequiresPortablePdb" xml:space="preserve">
-    <value>/sourcelink switch is only supported when emitting Portable PDB (/debug:portable or /debug:embedded must be specified).</value>
+  <data name="ERR_SourceLinkRequiresPdb" xml:space="preserve">
+    <value>/sourcelink switch is only supported when emitting PDB.</value>
   </data>
   <data name="ERR_CannotEmbedWithoutPdb" xml:space="preserve">
     <value>/embed switch is only supported when emitting Portable PDB (/debug:portable or /debug:embedded).</value>
diff --git a/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs b/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
index c14b627d769c1..deb01386ff63e 100644
--- a/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
+++ b/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
@@ -1193,12 +1193,9 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
                 keyFileSetting = ParseGenericPathToFile(keyFileSetting, diagnostics, baseDirectory);
             }
 
-            if (sourceLink != null)
+            if (sourceLink != null && !emitPdb)
             {
-                if (!emitPdb || !debugInformationFormat.IsPortable())
-                {
-                    AddDiagnostic(diagnostics, ErrorCode.ERR_SourceLinkRequiresPortablePdb);
-                }
+                AddDiagnostic(diagnostics, ErrorCode.ERR_SourceLinkRequiresPdb);
             }
             
             if (embedAllSourceFiles)
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index 6c6cbeb3ee268..3ed35efce1427 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -1060,7 +1060,7 @@ internal enum ErrorCode
         ERR_InvalidOutputName = 2041,
         ERR_InvalidDebugInformationFormat = 2042,
         ERR_LegacyObjectIdSyntax = 2043,
-        ERR_SourceLinkRequiresPortablePdb = 2044,
+        ERR_SourceLinkRequiresPdb = 2044,
         ERR_CannotEmbedWithoutPdb = 2045,
         // unused 2046-2999
         WRN_CLS_NoVarArgs = 3000,
diff --git a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
index b63e0120146af..9f9ed6865138b 100644
--- a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
+++ b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
@@ -25,9 +25,8 @@
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Xunit;
-
-using static Roslyn.Test.Utilities.SharedResourceHelpers;
 using static Microsoft.CodeAnalysis.CommonDiagnosticAnalyzers;
+using static Roslyn.Test.Utilities.SharedResourceHelpers;
 
 namespace Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests
 {
@@ -1725,19 +1724,19 @@ public void SourceLink()
             Assert.Equal(Path.Combine(_baseDirectory, "s l.json"), parsedArgs.SourceLink);
 
             parsedArgs = DefaultParse(new[] { "/sourcelink:sl.json", "/debug:full", "a.cs" }, _baseDirectory);
-            parsedArgs.Errors.Verify(Diagnostic(ErrorCode.ERR_SourceLinkRequiresPortablePdb));
+            parsedArgs.Errors.Verify();
 
             parsedArgs = DefaultParse(new[] { "/sourcelink:sl.json", "/debug:pdbonly", "a.cs" }, _baseDirectory);
-            parsedArgs.Errors.Verify(Diagnostic(ErrorCode.ERR_SourceLinkRequiresPortablePdb));
+            parsedArgs.Errors.Verify();
 
             parsedArgs = DefaultParse(new[] { "/sourcelink:sl.json", "/debug-", "a.cs" }, _baseDirectory);
-            parsedArgs.Errors.Verify(Diagnostic(ErrorCode.ERR_SourceLinkRequiresPortablePdb));
+            parsedArgs.Errors.Verify(Diagnostic(ErrorCode.ERR_SourceLinkRequiresPdb));
 
             parsedArgs = DefaultParse(new[] { "/sourcelink:sl.json", "/debug+", "a.cs" }, _baseDirectory);
-            parsedArgs.Errors.Verify(Diagnostic(ErrorCode.ERR_SourceLinkRequiresPortablePdb));
+            parsedArgs.Errors.Verify();
 
             parsedArgs = DefaultParse(new[] { "/sourcelink:sl.json", "a.cs" }, _baseDirectory);
-            parsedArgs.Errors.Verify(Diagnostic(ErrorCode.ERR_SourceLinkRequiresPortablePdb));
+            parsedArgs.Errors.Verify(Diagnostic(ErrorCode.ERR_SourceLinkRequiresPdb));
         }
 
         [Fact]
@@ -1800,6 +1799,31 @@ public void SourceLink_EndToEnd_Portable()
             CleanupAllGeneratedFiles(src.Path);
         }
 
+        [Fact]
+        public void SourceLink_EndToEnd_Windows()
+        {
+            var dir = Temp.CreateDirectory();
+
+            var src = dir.CreateFile("a.cs");
+            src.WriteAllText(@"class C { public static void Main() {} }");
+
+            var sl = dir.CreateFile("sl.json");
+            byte[] slContent = Encoding.UTF8.GetBytes(@"{ ""documents"" : {} }");
+            sl.WriteAllBytes(slContent);
+
+            var outWriter = new StringWriter(CultureInfo.InvariantCulture);
+            var csc = new MockCSharpCompiler(null, dir.Path, new[] { "/nologo", "/debug:full", "/sourcelink:sl.json", "a.cs" });
+            int exitCode = csc.Run(outWriter);
+            Assert.Equal(0, exitCode);
+
+            var pdbStream = File.OpenRead(Path.Combine(dir.Path, "a.pdb"));
+            var actualData = PdbValidation.GetSourceLinkData(pdbStream);
+            AssertEx.Equal(slContent, actualData);
+
+            // Clean up temp files
+            CleanupAllGeneratedFiles(src.Path);
+        }
+
         [Fact]
         public void Embed()
         {
@@ -7275,12 +7299,14 @@ public void IOFailure_DisposeXmlFile()
             Assert.Equal($"error CS0016: Could not write to output file '{xmlPath}' -- 'Fake IOException'{Environment.NewLine}", outWriter.ToString());
         }
 
-        [Fact]
-        public void IOFailure_DisposeSourceLinkFile()
+        [Theory]
+        [InlineData("portable")]
+        [InlineData("full")]
+        public void IOFailure_DisposeSourceLinkFile(string format)
         {
             var srcPath = MakeTrivialExe(Temp.CreateDirectory().Path);
             var sourceLinkPath = Path.Combine(Path.GetDirectoryName(srcPath), "test.json");
-            var csc = new MockCSharpCompiler(null, _baseDirectory, new[] { "/nologo", "/preferreduilang:en", "/debug:portable", $"/sourcelink:{sourceLinkPath}", srcPath });
+            var csc = new MockCSharpCompiler(null, _baseDirectory, new[] { "/nologo", "/preferreduilang:en", "/debug:" + format, $"/sourcelink:{sourceLinkPath}", srcPath });
             csc.FileOpen = (file, mode, access, share) =>
             {
                 if (file == sourceLinkPath)
diff --git a/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj b/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj
index 0d8951495e9e2..2a8c915886eb3 100644
--- a/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj
+++ b/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj
@@ -159,6 +159,7 @@
     <Compile Include="PDB\CSharpPDBTestBase.cs" />
     <Compile Include="PDB\PDBIteratorTests.cs" />
     <Compile Include="PDB\PDBLambdaTests.cs" />
+    <Compile Include="PDB\PDBSourceLinkTests.cs" />
     <Compile Include="PDB\PDBTests.cs" />
     <Compile Include="PDB\PDBTupleTests.cs" />
     <Compile Include="PDB\PDBUsingTests.cs" />
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBSourceLinkTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBSourceLinkTests.cs
new file mode 100644
index 0000000000000..0afa594315b6b
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBSourceLinkTests.cs
@@ -0,0 +1,153 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection.Metadata;
+using System.Reflection.PortableExecutable;
+using System.Text;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Debugging;
+using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests.PDB
+{
+    public class PDBSourceLinkTests : CSharpPDBTestBase
+    {
+        [Theory]
+        [InlineData(DebugInformationFormat.Pdb)]
+        [InlineData(DebugInformationFormat.PortablePdb)]
+        public void SourceLink(DebugInformationFormat format)
+        {
+            string source = @"
+using System;
+
+class C
+{
+    public static void Main()
+    {
+        Console.WriteLine();
+    }
+}
+";
+            var sourceLinkBlob = Encoding.UTF8.GetBytes(@"
+{
+  ""documents"": {
+     ""f:/build/*"" : ""https://raw.githubusercontent.com/my-org/my-project/1111111111111111111111111111111111111111/*""
+  }
+}
+");
+
+            var c = CreateStandardCompilation(Parse(source, "f:/build/foo.cs"), options: TestOptions.DebugDll);
+
+            var pdbStream = new MemoryStream();
+            c.EmitToArray(EmitOptions.Default.WithDebugInformationFormat(format), pdbStream: pdbStream, sourceLinkStream: new MemoryStream(sourceLinkBlob));
+
+            var actualData = PdbValidation.GetSourceLinkData(pdbStream);
+            AssertEx.Equal(sourceLinkBlob, actualData);
+        }
+
+        [Fact]
+        public void SourceLink_Embedded()
+        {
+            string source = @"
+using System;
+
+class C
+{
+    public static void Main()
+    {
+        Console.WriteLine();
+    }
+}
+";
+            var sourceLinkBlob = Encoding.UTF8.GetBytes(@"
+{
+  ""documents"": {
+     ""f:/build/*"" : ""https://raw.githubusercontent.com/my-org/my-project/1111111111111111111111111111111111111111/*""
+  }
+}
+");
+            var c = CreateStandardCompilation(Parse(source, "f:/build/foo.cs"), options: TestOptions.DebugDll);
+
+            var peBlob = c.EmitToArray(EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.Embedded), sourceLinkStream: new MemoryStream(sourceLinkBlob));
+
+            using (var peReader = new PEReader(peBlob))
+            {
+                var embeddedEntry = peReader.ReadDebugDirectory().Single(e => e.Type == DebugDirectoryEntryType.EmbeddedPortablePdb);
+
+                using (var embeddedMetadataProvider = peReader.ReadEmbeddedPortablePdbDebugDirectoryData(embeddedEntry))
+                {
+                    var pdbReader = embeddedMetadataProvider.GetMetadataReader();
+
+                    var actualBlob =
+                        (from cdiHandle in pdbReader.GetCustomDebugInformation(EntityHandle.ModuleDefinition)
+                         let cdi = pdbReader.GetCustomDebugInformation(cdiHandle)
+                         where pdbReader.GetGuid(cdi.Kind) == PortableCustomDebugInfoKinds.SourceLink
+                         select pdbReader.GetBlobBytes(cdi.Value)).Single();
+
+                    AssertEx.Equal(sourceLinkBlob, actualBlob);
+                }
+            }
+        }
+
+        [Theory]
+        [InlineData(DebugInformationFormat.Pdb)]
+        [InlineData(DebugInformationFormat.Embedded)]
+        [InlineData(DebugInformationFormat.PortablePdb)]
+        public void SourceLink_Errors(DebugInformationFormat format)
+        {
+            string source = @"
+using System;
+
+class C
+{
+    public static void Main()
+    {
+        Console.WriteLine();
+    }
+}
+";
+            var sourceLinkStream = new TestStream(canRead: true, readFunc: (_, __, ___) => { throw new Exception("Error!"); });
+
+            var c = CreateStandardCompilation(Parse(source, "f:/build/foo.cs"), options: TestOptions.DebugDll);
+            var pdbStream = format != DebugInformationFormat.Embedded ? new MemoryStream() : null;
+            var result = c.Emit(new MemoryStream(), pdbStream, options: EmitOptions.Default.WithDebugInformationFormat(format), sourceLinkStream: sourceLinkStream);
+            result.Diagnostics.Verify(
+                // error CS0041: Unexpected error writing debug information -- 'Error!'
+                Diagnostic(ErrorCode.FTL_DebugEmitFailure).WithArguments("Error!").WithLocation(1, 1));
+        }
+
+        [Theory]
+        [InlineData(DebugInformationFormat.Pdb)]
+        [InlineData(DebugInformationFormat.PortablePdb)]
+        public void SourceLink_Empty(DebugInformationFormat format)
+        {
+            string source = @"
+using System;
+
+class C
+{
+    public static void Main()
+    {
+        Console.WriteLine();
+    }
+}
+";
+            var sourceLinkBlob = new byte[0];
+
+            var c = CreateStandardCompilation(Parse(source, "f:/build/foo.cs"), options: TestOptions.DebugDll);
+
+            var pdbStream = new MemoryStream();
+            c.EmitToArray(EmitOptions.Default.WithDebugInformationFormat(format), pdbStream: pdbStream, sourceLinkStream: new MemoryStream(sourceLinkBlob));
+            pdbStream.Position = 0;
+            var bs = Roslyn.Utilities.StreamExtensions.ReadAllBytes(pdbStream);
+            var actualData = PdbValidation.GetSourceLinkData(pdbStream);
+            AssertEx.Equal(sourceLinkBlob, actualData);
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
index de4c796ed83eb..51a99debe4b3a 100644
--- a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
@@ -210,18 +210,6 @@ public void Emit_BadArgs()
                 options: EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.PortablePdb),
                 sourceLinkStream: new TestStream(canRead: false, canWrite: true, canSeek: true)));
 
-            Assert.Throws<ArgumentException>("sourceLinkStream", () => comp.Emit(
-               peStream: new MemoryStream(),
-               pdbStream: new MemoryStream(),
-               options: EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.Pdb),
-               sourceLinkStream: new MemoryStream()));
-
-            Assert.Throws<ArgumentException>("sourceLinkStream", () => comp.Emit(
-               peStream: new MemoryStream(),
-               pdbStream: null,
-               options: EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.PortablePdb),
-               sourceLinkStream: new MemoryStream()));
-
             Assert.Throws<ArgumentException>("embeddedTexts", () => comp.Emit(
                 peStream: new MemoryStream(),
                 pdbStream: new MemoryStream(),
diff --git a/src/Compilers/Core/CodeAnalysisTest/InternalUtilities/StreamExtensionsTests.cs b/src/Compilers/Core/CodeAnalysisTest/InternalUtilities/StreamExtensionsTests.cs
index 708facb9e0935..cc61e25fdc2da 100644
--- a/src/Compilers/Core/CodeAnalysisTest/InternalUtilities/StreamExtensionsTests.cs
+++ b/src/Compilers/Core/CodeAnalysisTest/InternalUtilities/StreamExtensionsTests.cs
@@ -11,7 +11,7 @@ namespace Roslyn.Utilities.UnitTests.InternalUtilities
     public class StreamExtensionsTests
     {
         [Fact]
-        public void CallsReadMultipleTimes()
+        public void TryReadAll_CallsReadMultipleTimes()
         {
             var firstRead = true;
             var sourceArray = new byte[] { 1, 2, 3, 4 };
@@ -37,7 +37,7 @@ public void CallsReadMultipleTimes()
         }
 
         [Fact]
-        public void ExceptionsPropagate()
+        public void TryReadAll_ExceptionsPropagate()
         {
             var buffer = new byte[10];
 
@@ -57,7 +57,7 @@ public void ExceptionsPropagate()
         }
 
         [Fact]
-        public void ExceptionMayChangeOutput()
+        public void TryReadAll_ExceptionMayChangeOutput()
         {
             var firstRead = true;
             var sourceArray = new byte[] { 1, 2, 3, 4 };
@@ -82,7 +82,7 @@ public void ExceptionMayChangeOutput()
         }
 
         [Fact]
-        public void ExceptionMayChangePosition()
+        public void TryReadAll_ExceptionMayChangePosition()
         {
             var firstRead = true;
             var sourceArray = new byte[] { 1, 2, 3, 4 };
@@ -107,7 +107,7 @@ public void ExceptionMayChangePosition()
         }
 
         [Fact]
-        public void PrematureEndOfStream()
+        public void TryReadAll_PrematureEndOfStream()
         {
             var sourceArray = new byte[] { 1, 2, 3, 4 };
             var stream = new MemoryStream(sourceArray);
@@ -118,5 +118,38 @@ public void PrematureEndOfStream()
             var expected = new byte[] { 1, 2, 3, 4, 0, 0 };
             Assert.Equal(expected, destArray);
         }
+
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void ReadAllBytes(bool canSeek)
+        {
+            var sourceArray = new byte[] { 1, 2, 3, 4 };
+            var stream = new TestStream(canSeek: canSeek, backingStream: new MemoryStream(sourceArray));
+            stream.ReadByte();
+            Assert.Equal(new byte[] { 2, 3, 4 }, stream.ReadAllBytes());
+        }
+
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void ReadAllBytes_End(bool canSeek)
+        {
+            var sourceArray = new byte[] { 1, 2 };
+            var stream = new TestStream(canSeek: canSeek, backingStream: new MemoryStream(sourceArray));
+            stream.ReadByte();
+            stream.ReadByte();
+            Assert.Equal(new byte[0], stream.ReadAllBytes());
+        }
+
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void ReadAllBytes_Resize(bool canSeek)
+        {
+            var sourceArray = new byte[] { 1, 2 };
+            var stream = new TestStream(canSeek: canSeek, backingStream: new MemoryStream(sourceArray), length: 3);
+            Assert.Equal(new byte[] { 1, 2 }, stream.ReadAllBytes());
+        }
     }
 }
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
index 478cae1ae4eae..1fcb0662afc5e 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
@@ -1189,15 +1189,6 @@ internal static string SizeHasToBePositive {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Source Link embedding is only supported when emitting Portable PDB..
-        /// </summary>
-        internal static string SourceLinkRequiresPortablePdb {
-            get {
-                return ResourceManager.GetString("SourceLinkRequiresPortablePdb", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to SourceText cannot be embedded. Provide encoding or canBeEmbedded=true at construction..
         /// </summary>
@@ -1291,6 +1282,15 @@ internal static string Struct1 {
         /// <summary>
         ///   Looks up a localized string similar to Windows PDB writer doesn&apos;t support deterministic compilation: &apos;{0}&apos;.
         /// </summary>
+        internal static string SymWriterDoesNotSupportSourceLink {
+            get {
+                return ResourceManager.GetString("SymWriterDoesNotSupportSourceLink", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Windows PDB writer is not available -- could not find Microsoft.DiaSymReader.Native.{0}.dll.
+        /// </summary>
         internal static string SymWriterNotDeterministic {
             get {
                 return ResourceManager.GetString("SymWriterNotDeterministic", resourceCulture);
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.resx b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
index 96cd5f06360ee..73efdfebe9ba8 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.resx
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
@@ -470,6 +470,9 @@
   <data name="SymWriterOlderVersionThanRequired" xml:space="preserve">
     <value>The version of Windows PDB writer is older than required: '{0}'</value>
   </data>
+  <data name="SymWriterDoesNotSupportSourceLink" xml:space="preserve">
+    <value>Windows PDB writer doesn't support SourceLink feature: '{0}'</value>
+  </data>
   <data name="RuleSetBadAttributeValue" xml:space="preserve">
     <value>The attribute {0} has an invalid value of {1}.</value>
   </data>
@@ -561,9 +564,6 @@
   <data name="IOperationFeatureDisabled" xml:space="preserve">
     <value>Feature 'IOperation' is disabled.</value>
   </data>
-  <data name="SourceLinkRequiresPortablePdb" xml:space="preserve">
-    <value>Source Link embedding is only supported when emitting Portable PDB.</value>
-  </data>
   <data name="UnrecognizedResourceFileFormat" xml:space="preserve">
     <value>Unrecognized resource file format.</value>
   </data>
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index c270b6573f891..0865c4659a0e8 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -1991,7 +1991,6 @@ public EmitResult Emit(
         /// </param>
         /// <param name="sourceLinkStream">
         /// Stream containing information linking the compilation to a source control.
-        /// Only supported when emitting Portable PDBs.
         /// </param>
         /// <param name="embeddedTexts">
         /// Texts to embed in the PDB.
@@ -2041,20 +2040,11 @@ public EmitResult Emit(
                 }
             }
 
-            if (sourceLinkStream != null)
+            if (sourceLinkStream != null && !sourceLinkStream.CanRead)
             {
-                if (options == null || 
-                    options.DebugInformationFormat == DebugInformationFormat.Pdb ||
-                    options.DebugInformationFormat == DebugInformationFormat.PortablePdb && pdbStream == null)
-                {
-                    throw new ArgumentException(CodeAnalysisResources.SourceLinkRequiresPortablePdb, nameof(sourceLinkStream));
-                }
-
-                if (!sourceLinkStream.CanRead)
-                {
-                    throw new ArgumentException(CodeAnalysisResources.StreamMustSupportRead, nameof(sourceLinkStream));
-                }
+                throw new ArgumentException(CodeAnalysisResources.StreamMustSupportRead, nameof(sourceLinkStream));
             }
+
             if (embeddedTexts != null && !embeddedTexts.IsEmpty())
             {
                 if (options == null || 
diff --git a/src/Compilers/Core/Portable/InternalUtilities/StreamExtensions.cs b/src/Compilers/Core/Portable/InternalUtilities/StreamExtensions.cs
index 1c4fc9fb4b4e2..c1dabc5901254 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/StreamExtensions.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/StreamExtensions.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Diagnostics;
 using System.IO;
 
@@ -47,5 +48,29 @@ public static int TryReadAll(
             }
             return totalBytesRead;
         }
+
+        /// <summary>
+        /// Reads all bytes from the current postion of the given stream to its end.
+        /// </summary>
+        public static byte[] ReadAllBytes(this Stream stream)
+        {
+            if (stream.CanSeek)
+            {
+                long length = stream.Length - stream.Position;
+                if (length == 0)
+                {
+                    return Array.Empty<byte>();
+                }
+
+                var buffer = new byte[length];
+                int actualLength = TryReadAll(stream, buffer, 0, buffer.Length);
+                Array.Resize(ref buffer, actualLength);
+                return buffer;
+            }
+
+            var memoryStream = new MemoryStream();
+            stream.CopyTo(memoryStream);
+            return memoryStream.ToArray();
+        }
     }
 }
diff --git a/src/Compilers/Core/Portable/NativePdbWriter/ISymUnmanagedWriter.cs b/src/Compilers/Core/Portable/NativePdbWriter/ISymUnmanagedWriter.cs
index 33ed19958582e..fe57c59b2f9ef 100644
--- a/src/Compilers/Core/Portable/NativePdbWriter/ISymUnmanagedWriter.cs
+++ b/src/Compilers/Core/Portable/NativePdbWriter/ISymUnmanagedWriter.cs
@@ -109,8 +109,8 @@ void DefineSequencePoints(ISymUnmanagedDocumentWriter document, uint count,
     /// <summary>
     /// The highest version of the interface available in Microsoft.DiaSymReader.Native.
     /// </summary>
-    [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("22DAEAF2-70F6-4EF1-B0C3-984F0BF27BFD"), SuppressUnmanagedCodeSecurity]
-    internal interface ISymUnmanagedWriter7 : ISymUnmanagedWriter5
+    [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("5ba52f3b-6bf8-40fc-b476-d39c529b331e"), SuppressUnmanagedCodeSecurity]
+    internal interface ISymUnmanagedWriter8 : ISymUnmanagedWriter5
     {
         //  ISymUnmanagedWriter, ISymUnmanagedWriter2, ISymUnmanagedWriter3, ISymUnmanagedWriter4, ISymUnmanagedWriter5
         void _VtblGap1_33();
@@ -120,6 +120,11 @@ internal interface ISymUnmanagedWriter7 : ISymUnmanagedWriter5
 
         // ISymUnmanagedWriter7
         unsafe void UpdateSignatureByHashingContent([In]byte* buffer, int size);
+
+        // ISymUnmanagedWriter8
+        void UpdateSignature(Guid pdbId, uint stamp, int age);
+        unsafe void SetSourceServerData([In]byte* data, int size);
+        unsafe void SetSourceLinkData([In]byte* data, int size);
     }
 
     [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("98ECEE1E-752D-11d3-8D56-00C04F680B2B"), SuppressUnmanagedCodeSecurity]
diff --git a/src/Compilers/Core/Portable/NativePdbWriter/PdbWriter.cs b/src/Compilers/Core/Portable/NativePdbWriter/PdbWriter.cs
index bcbb76264c431..61df6cfcb0a99 100644
--- a/src/Compilers/Core/Portable/NativePdbWriter/PdbWriter.cs
+++ b/src/Compilers/Core/Portable/NativePdbWriter/PdbWriter.cs
@@ -120,7 +120,8 @@ internal enum PdbWriterOperation : byte
             OpenMapTokensToSourceSpans,
             MapTokenToSourceSpan,
             CloseMapTokensToSourceSpans,
-            SetSource
+            SetSource,
+            SetSourceLinkData,
         }
 
         public bool LogOperation(PdbWriterOperation op)
@@ -825,9 +826,9 @@ public void SetMetadataEmitter(MetadataWriter metadataWriter)
                 {
                     symWriter.Initialize(new PdbMetadataWrapper(metadataWriter), _fileName, _pdbStream, fullBuild: true);
                 }
-                else if (symWriter is ISymUnmanagedWriter7 symWriter7)
+                else if (symWriter is ISymUnmanagedWriter8 symWriter8)
                 {
-                    symWriter7.InitializeDeterministic(new PdbMetadataWrapper(metadataWriter), _pdbStream);
+                    symWriter8.InitializeDeterministic(new PdbMetadataWrapper(metadataWriter), _pdbStream);
                 }
                 else
                 {
@@ -855,7 +856,7 @@ public unsafe BlobContentId GetContentId()
                 {
                     fixed (byte* hashPtr = &hash[0])
                     {
-                        ((ISymUnmanagedWriter7)_symWriter).UpdateSignatureByHashingContent(hashPtr, hash.Length);
+                        ((ISymUnmanagedWriter8)_symWriter).UpdateSignatureByHashingContent(hashPtr, hash.Length);
                     }
                 }
                 catch (Exception ex)
@@ -1505,6 +1506,34 @@ public void WriteDefinitionLocations(MultiDictionary<DebugSourceDocument, Defini
             }
         }
 
+        public unsafe void EmbedSourceLink(Stream stream)
+        {
+            if (!(_symWriter is ISymUnmanagedWriter8 symWriter8))
+            {
+                throw new NotSupportedException(string.Format(CodeAnalysisResources.SymWriterDoesNotSupportSourceLink, LoadedDiaSymReaderModuleName));
+            }
+
+            try
+            {
+                var buffer = stream.ReadAllBytes();
+
+                fixed (byte* bufferPtr = buffer)
+                {
+                    byte b = 0;
+                    symWriter8.SetSourceLinkData((bufferPtr != null) ? bufferPtr : &b, buffer.Length);
+                }
+
+                if (_callLogger.LogOperation(OP.SetSourceLinkData))
+                {
+                    _callLogger.LogArgument(buffer);
+                }
+            }
+            catch (Exception e) when (!(e is OperationCanceledException))
+            {
+                throw new PdbWritingException(e);
+            }
+        }
+
         #endregion
     }
 }
diff --git a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.PortablePdb.cs b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.PortablePdb.cs
index 30169e708f71a..7012879dd30a0 100644
--- a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.PortablePdb.cs
+++ b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.PortablePdb.cs
@@ -803,11 +803,11 @@ private void SerializeEncMethodDebugInformation(IMethodBody methodBody, MethodDe
 
         private void EmbedSourceLink(Stream stream)
         {
-            // TODO: be more efficient: https://github.com/dotnet/roslyn/issues/12853
-            var memoryStream = new MemoryStream();
+            byte[] bytes;
+
             try
             {
-                stream.CopyTo(memoryStream);
+                bytes = stream.ReadAllBytes();
             }
             catch (Exception e) when (!(e is OperationCanceledException))
             {
@@ -817,7 +817,7 @@ private void EmbedSourceLink(Stream stream)
             _debugMetadataOpt.AddCustomDebugInformation(
                 parent: EntityHandle.ModuleDefinition,
                 kind: _debugMetadataOpt.GetOrAddGuid(PortableCustomDebugInfoKinds.SourceLink),
-                value: _debugMetadataOpt.GetOrAddBlob(memoryStream.ToArray()));
+                value: _debugMetadataOpt.GetOrAddBlob(bytes));
         }
     }
 }
diff --git a/src/Compilers/Core/Portable/PEWriter/PeWriter.cs b/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
index b2d4a571f38ac..df55ad7594eb3 100644
--- a/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
@@ -75,6 +75,11 @@ public static bool WritePeToStream(
 
             if (nativePdbWriterOpt != null)
             {
+                if (context.Module.SourceLinkStreamOpt != null)
+                {
+                    nativePdbWriterOpt.EmbedSourceLink(context.Module.SourceLinkStreamOpt);
+                }
+
                 if (mdWriter.Module.OutputKind == OutputKind.WindowsRuntimeMetadata)
                 {
                     // Dev12: If compiling to winmdobj, we need to add to PDB source spans of
diff --git a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
index de04a2d14d671..8e6ce6168ca62 100644
--- a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
+++ b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
@@ -1239,10 +1239,8 @@ lVbRuntimePlus:
 
             ValidateWin32Settings(noWin32Manifest, win32ResourceFile, win32IconFile, win32ManifestFile, outputKind, diagnostics)
 
-            If sourceLink IsNot Nothing Then
-                If Not emitPdb OrElse debugInformationFormat <> DebugInformationFormat.PortablePdb AndAlso debugInformationFormat <> DebugInformationFormat.Embedded Then
-                    AddDiagnostic(diagnostics, ERRID.ERR_SourceLinkRequiresPortablePdb)
-                End If
+            If sourceLink IsNot Nothing And Not emitPdb Then
+                AddDiagnostic(diagnostics, ERRID.ERR_SourceLinkRequiresPdb)
             End If
 
             If embedAllSourceFiles Then
diff --git a/src/Compilers/VisualBasic/Portable/Errors/Errors.vb b/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
index 2b1e55429e4d0..e80c45b05247b 100644
--- a/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
+++ b/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
@@ -1696,7 +1696,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
         ERR_RefReturningCallInExpressionTree = 37263
 
-        ERR_SourceLinkRequiresPortablePdb = 37264
+        ERR_SourceLinkRequiresPdb = 37264
         ERR_CannotEmbedWithoutPdb = 37265
 
         ERR_InvalidInstrumentationKind = 37266
diff --git a/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb b/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb
index f3cc8d7983f6d..a827d691c4349 100644
--- a/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb
+++ b/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb
@@ -10037,11 +10037,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         End Property
         
         '''<summary>
-        '''  Looks up a localized string similar to /sourcelink switch is only supported when emitting Portable PDB (/debug:portable or /debug:embedded must be specified)..
+        '''  Looks up a localized string similar to /sourcelink switch is only supported when emitting PDB..
         '''</summary>
-        Friend ReadOnly Property ERR_SourceLinkRequiresPortablePdb() As String
+        Friend ReadOnly Property ERR_SourceLinkRequiresPdb() As String
             Get
-                Return ResourceManager.GetString("ERR_SourceLinkRequiresPortablePdb", resourceCulture)
+                Return ResourceManager.GetString("ERR_SourceLinkRequiresPdb", resourceCulture)
             End Get
         End Property
         
diff --git a/src/Compilers/VisualBasic/Portable/VBResources.resx b/src/Compilers/VisualBasic/Portable/VBResources.resx
index 67dc422629514..7bef84cd0b6db 100644
--- a/src/Compilers/VisualBasic/Portable/VBResources.resx
+++ b/src/Compilers/VisualBasic/Portable/VBResources.resx
@@ -5107,7 +5107,7 @@
                                   (including module version GUID and timestamp)
 /instrument:TestCoverage          Produce an assembly instrumented to collect
                                   coverage information
-/sourcelink:&lt;file&gt;                Source link info to embed into Portable PDB.
+/sourcelink:&lt;file&gt;                Source link info to embed into PDB.
 
                                   - ERRORS AND WARNINGS -
 /nowarn                           Disable all warnings.
@@ -5418,8 +5418,8 @@
   <data name="ERR_OptionMustBeAbsolutePath" xml:space="preserve">
     <value>Option '{0}' must be an absolute path.</value>
   </data>
-  <data name="ERR_SourceLinkRequiresPortablePdb" xml:space="preserve">
-    <value>/sourcelink switch is only supported when emitting Portable PDB (/debug:portable or /debug:embedded must be specified).</value>
+  <data name="ERR_SourceLinkRequiresPdb" xml:space="preserve">
+    <value>/sourcelink switch is only supported when emitting PDB.</value>
   </data>
   <data name="ERR_TupleDuplicateElementName" xml:space="preserve">
     <value>Tuple element names must be unique.</value>
diff --git a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
index 84f612cb5eb24..fa6de58103a09 100644
--- a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
+++ b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
@@ -2657,19 +2657,19 @@ End Module").Path
             Assert.Equal(Path.Combine(_baseDirectory, "s l.json"), parsedArgs.SourceLink)
 
             parsedArgs = DefaultParse({"/sourcelink:sl.json", "/debug:full", "a.vb"}, _baseDirectory)
-            parsedArgs.Errors.Verify(Diagnostic(ERRID.ERR_SourceLinkRequiresPortablePdb))
+            parsedArgs.Errors.Verify()
 
             parsedArgs = DefaultParse({"/sourcelink:sl.json", "/debug:pdbonly", "a.vb"}, _baseDirectory)
-            parsedArgs.Errors.Verify(Diagnostic(ERRID.ERR_SourceLinkRequiresPortablePdb))
+            parsedArgs.Errors.Verify()
 
             parsedArgs = DefaultParse({"/sourcelink:sl.json", "/debug-", "a.vb"}, _baseDirectory)
-            parsedArgs.Errors.Verify(Diagnostic(ERRID.ERR_SourceLinkRequiresPortablePdb))
+            parsedArgs.Errors.Verify(Diagnostic(ERRID.ERR_SourceLinkRequiresPdb))
 
             parsedArgs = DefaultParse({"/sourcelink:sl.json", "/debug+", "a.vb"}, _baseDirectory)
-            parsedArgs.Errors.Verify(Diagnostic(ERRID.ERR_SourceLinkRequiresPortablePdb))
+            parsedArgs.Errors.Verify()
 
             parsedArgs = DefaultParse({"/sourcelink:sl.json", "a.vb"}, _baseDirectory)
-            parsedArgs.Errors.Verify(Diagnostic(ERRID.ERR_SourceLinkRequiresPortablePdb))
+            parsedArgs.Errors.Verify(Diagnostic(ERRID.ERR_SourceLinkRequiresPdb))
         End Sub
 
         <Fact>
@@ -8252,11 +8252,13 @@ End Module
             Assert.Equal($"error BC2012: can't open '{xmlPath}' for writing: Fake IOException{Environment.NewLine}", outWriter.ToString())
         End Sub
 
-        <Fact>
-        Public Sub IOFailure_DisposeSourceLinkFile()
+        <Theory>
+        <InlineData("portable")>
+        <InlineData("full")>
+        Public Sub IOFailure_DisposeSourceLinkFile(format As String)
             Dim srcPath = MakeTrivialExe(Temp.CreateDirectory().Path)
             Dim sourceLinkPath = Path.Combine(Path.GetDirectoryName(srcPath), "test.json")
-            Dim csc = New MockVisualBasicCompiler(_baseDirectory, {"/nologo", "/preferreduilang:en", "/debug:portable", $"/sourcelink:{sourceLinkPath}", srcPath})
+            Dim csc = New MockVisualBasicCompiler(_baseDirectory, {"/nologo", "/preferreduilang:en", "/debug:" & format, $"/sourcelink:{sourceLinkPath}", srcPath})
             csc.FileOpen = Function(filePath, mode, access, share)
                                If filePath = sourceLinkPath Then
                                    Return New TestStream(
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Compilation/CompilationAPITests.vb b/src/Compilers/VisualBasic/Test/Semantic/Compilation/CompilationAPITests.vb
index 3674b2d1225c6..5c25c3217506c 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Compilation/CompilationAPITests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Compilation/CompilationAPITests.vb
@@ -285,18 +285,6 @@ End Namespace
                 options:=EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.PortablePdb),
                 sourceLinkStream:=New TestStream(canRead:=False, canWrite:=True, canSeek:=True)))
 
-            Assert.Throws(Of ArgumentException)("sourceLinkStream", Sub() comp.Emit(
-                peStream:=New MemoryStream(),
-                pdbStream:=New MemoryStream(),
-                options:=EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.Pdb),
-                sourceLinkStream:=New MemoryStream()))
-
-            Assert.Throws(Of ArgumentException)("sourceLinkStream", Sub() comp.Emit(
-                peStream:=New MemoryStream(),
-                pdbStream:=Nothing,
-                options:=EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.PortablePdb),
-                sourceLinkStream:=New MemoryStream()))
-
             Assert.Throws(Of ArgumentException)("embeddedTexts", Sub() comp.Emit(
                 peStream:=New MemoryStream(),
                 pdbStream:=New MemoryStream(),
diff --git a/src/Test/PdbUtilities/Pdb/SymReaderFactory.cs b/src/Test/PdbUtilities/Pdb/SymReaderFactory.cs
index 9538682fb451b..2502719b6dbe4 100644
--- a/src/Test/PdbUtilities/Pdb/SymReaderFactory.cs
+++ b/src/Test/PdbUtilities/Pdb/SymReaderFactory.cs
@@ -23,7 +23,7 @@ public static class SymReaderFactory
         [DllImport("Microsoft.DiaSymReader.Native.amd64.dll", EntryPoint = "CreateSymReader")]
         private extern static void CreateSymReader64(ref Guid id, [MarshalAs(UnmanagedType.IUnknown)]out object symReader);
 
-        private static ISymUnmanagedReader3 CreateNativeSymReader(Stream pdbStream, object metadataImporter)
+        private static ISymUnmanagedReader5 CreateNativeSymReader(Stream pdbStream, object metadataImporter)
         {
             object symReader = null;
 
@@ -37,42 +37,42 @@ private static ISymUnmanagedReader3 CreateNativeSymReader(Stream pdbStream, obje
                 CreateSymReader64(ref guid, out symReader);
             }
 
-            var reader = (ISymUnmanagedReader3)symReader;
+            var reader = (ISymUnmanagedReader5)symReader;
             reader.Initialize(pdbStream, metadataImporter);
             return reader;
         }
 
-        private static ISymUnmanagedReader3 CreatePortableSymReader(Stream pdbStream, object metadataImporter)
+        private static ISymUnmanagedReader5 CreatePortableSymReader(Stream pdbStream, object metadataImporter)
         {
-            return (ISymUnmanagedReader3)new PortablePdb.SymBinder().GetReaderFromStream(pdbStream, metadataImporter);
+            return (ISymUnmanagedReader5)new PortablePdb.SymBinder().GetReaderFromStream(pdbStream, metadataImporter);
         }
 
-        public static ISymUnmanagedReader3 CreateReader(byte[] pdbImage, byte[] peImageOpt = null)
+        public static ISymUnmanagedReader5 CreateReader(byte[] pdbImage, byte[] peImageOpt = null)
         {
             return CreateReader(new MemoryStream(pdbImage), (peImageOpt != null) ? new PEReader(new MemoryStream(peImageOpt)) : null);
         }
 
-        public static ISymUnmanagedReader3 CreateReader(ImmutableArray<byte> pdbImage, ImmutableArray<byte> peImageOpt = default(ImmutableArray<byte>))
+        public static ISymUnmanagedReader5 CreateReader(ImmutableArray<byte> pdbImage, ImmutableArray<byte> peImageOpt = default(ImmutableArray<byte>))
         {
             return CreateReader(new MemoryStream(pdbImage.ToArray()), (peImageOpt.IsDefault) ? null : new PEReader(peImageOpt));
         }
 
-        public static ISymUnmanagedReader3 CreateReader(Stream pdbStream, Stream peStreamOpt = null)
+        public static ISymUnmanagedReader5 CreateReader(Stream pdbStream, Stream peStreamOpt = null)
         {
             return CreateReader(pdbStream, (peStreamOpt != null) ? new PEReader(peStreamOpt) : null);
         }
 
-        public static ISymUnmanagedReader3 CreateReader(Stream pdbStream, PEReader peReaderOpt)
+        public static ISymUnmanagedReader5 CreateReader(Stream pdbStream, PEReader peReaderOpt)
         {
             return CreateReader(pdbStream, peReaderOpt?.GetMetadataReader(), peReaderOpt);
         }
 
-        public static ISymUnmanagedReader3 CreateReader(Stream pdbStream, MetadataReader metadataReaderOpt, IDisposable metadataMemoryOwnerOpt)
+        public static ISymUnmanagedReader5 CreateReader(Stream pdbStream, MetadataReader metadataReaderOpt, IDisposable metadataMemoryOwnerOpt)
         {
             return CreateReaderImpl(pdbStream, metadataImporter: new DummyMetadataImport(metadataReaderOpt, metadataMemoryOwnerOpt));
         }
 
-        public static ISymUnmanagedReader3 CreateReaderImpl(Stream pdbStream, object metadataImporter)
+        public static ISymUnmanagedReader5 CreateReaderImpl(Stream pdbStream, object metadataImporter)
         {
             pdbStream.Position = 0;
             bool isPortable = pdbStream.ReadByte() == 'B' && pdbStream.ReadByte() == 'S' && pdbStream.ReadByte() == 'J' && pdbStream.ReadByte() == 'B';
diff --git a/src/Test/Utilities/Portable/Pdb/PdbValidation.cs b/src/Test/Utilities/Portable/Pdb/PdbValidation.cs
index ef8158465840a..5e424fd6a2142 100644
--- a/src/Test/Utilities/Portable/Pdb/PdbValidation.cs
+++ b/src/Test/Utilities/Portable/Pdb/PdbValidation.cs
@@ -10,11 +10,13 @@
 using System.Reflection.Metadata.Ecma335;
 using System.Reflection.PortableExecutable;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using System.Text;
 using System.Xml;
 using System.Xml.Linq;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.Emit;
+using Microsoft.DiaSymReader;
 using Microsoft.DiaSymReader.Tools;
 using Microsoft.Metadata.Tools;
 using Roslyn.Test.MetadataUtilities;
@@ -265,11 +267,34 @@ internal static string GetPdbXml(
             return actual;
         }
 
+        public unsafe static byte[] GetSourceLinkData(Stream pdbStream)
+        {
+            pdbStream.Position = 0;
+
+            var symReader = SymReaderFactory.CreateReader(pdbStream);
+            try
+            {
+                Marshal.ThrowExceptionForHR(symReader.GetSourceServerData(out byte* data, out int size));
+                if (size == 0)
+                {
+                    return Array.Empty<byte>();
+                }
+
+                var result = new byte[size];
+                Marshal.Copy((IntPtr)data, result, 0, result.Length);
+                return result;
+            }
+            finally
+            {
+                ((ISymUnmanagedDispose)symReader).Destroy();
+            }
+        }
+
         public static void ValidateDebugDirectory(Stream peStream, Stream portablePdbStreamOpt, string pdbPath, bool isDeterministic)
         {
-            peStream.Seek(0, SeekOrigin.Begin);
-            PEReader peReader = new PEReader(peStream);
+            peStream.Position = 0;
 
+            var peReader = new PEReader(peStream);
             var debugDirectory = peReader.PEHeaders.PEHeader.DebugTableDirectory;
 
             int position;

From e9053e6b088fe4327ac68006e2763efcef39e70a Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Tue, 9 May 2017 13:09:18 -0700
Subject: [PATCH 070/284] Moved EditorInfoBarService to its own folder, export
 as workspace service

---
 .../{Workspaces => InfoBar}/EditorInfoBarService.cs      | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)
 rename src/EditorFeatures/Core/Implementation/{Workspaces => InfoBar}/EditorInfoBarService.cs (68%)

diff --git a/src/EditorFeatures/Core/Implementation/Workspaces/EditorInfoBarService.cs b/src/EditorFeatures/Core/Implementation/InfoBar/EditorInfoBarService.cs
similarity index 68%
rename from src/EditorFeatures/Core/Implementation/Workspaces/EditorInfoBarService.cs
rename to src/EditorFeatures/Core/Implementation/InfoBar/EditorInfoBarService.cs
index 5c98212530912..bd8a0567fd41b 100644
--- a/src/EditorFeatures/Core/Implementation/Workspaces/EditorInfoBarService.cs
+++ b/src/EditorFeatures/Core/Implementation/InfoBar/EditorInfoBarService.cs
@@ -1,13 +1,12 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
 using Microsoft.CodeAnalysis.Extensions;
+using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Internal.Log;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.Workspaces
 {
+    [ExportWorkspaceService(typeof(IInfoBarService))]
     internal class EditorInfoBarService : IInfoBarService
     {
         public void ShowInfoBarInActiveView(string message, params InfoBarUI[] items)

From d69c102665ba12b7ba920dfd5e3b4c47d04b6af2 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Tue, 9 May 2017 13:15:17 -0700
Subject: [PATCH 071/284] Moved VisualStudioInfoBarService, exported as
 workspace service

---
 .../VisualStudioInfoBarService.cs                      | 10 ++++++++--
 .../VisualStudioErrorReportingServiceFactory.cs        |  9 ++++++---
 2 files changed, 14 insertions(+), 5 deletions(-)
 rename src/VisualStudio/Core/Def/Implementation/{Workspace => InfoBar}/VisualStudioInfoBarService.cs (95%)

diff --git a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioInfoBarService.cs b/src/VisualStudio/Core/Def/Implementation/InfoBar/VisualStudioInfoBarService.cs
similarity index 95%
rename from src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioInfoBarService.cs
rename to src/VisualStudio/Core/Def/Implementation/InfoBar/VisualStudioInfoBarService.cs
index eac76f3fe4172..65c2f2f3d3b0c 100644
--- a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioInfoBarService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InfoBar/VisualStudioInfoBarService.cs
@@ -5,7 +5,9 @@
 using System.ComponentModel.Composition;
 using System.Linq;
 using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Extensions;
+using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.Imaging;
 using Microsoft.VisualStudio.Shell;
@@ -14,8 +16,8 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation
 {
-    [Export(typeof(IInfoBarService))]
-    internal class VisualStudioInfoBarService : IInfoBarService
+    [ExportWorkspaceService(typeof(IInfoBarService))]
+    internal class VisualStudioInfoBarService : ForegroundThreadAffinitizedObject, IInfoBarService
     {
         private readonly IServiceProvider _serviceProvider;
         private readonly IForegroundNotificationService _foregroundNotificationService;
@@ -33,11 +35,13 @@ public VisualStudioInfoBarService([Import(typeof(SVsServiceProvider))] IServiceP
 
         public void ShowInfoBarInActiveView(string message, params InfoBarUI[] items)
         {
+            ThisCanBeCalledOnAnyThread();
             ShowInfoBar(activeView: true, message: message, items: items);
         }
 
         public void ShowInfoBarInGlobalView(string message, params InfoBarUI[] items)
         {
+            ThisCanBeCalledOnAnyThread();
             ShowInfoBar(activeView: false, message: message, items: items);
         }
 
@@ -55,6 +59,8 @@ private void ShowInfoBar(bool activeView, string message, params InfoBarUI[] ite
 
         private bool TryGetInfoBarData(bool activeView, out IVsInfoBarHost infoBarHost)
         {
+            AssertIsForeground();
+
             infoBarHost = null;
 
             if (activeView)
diff --git a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingServiceFactory.cs b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingServiceFactory.cs
index 4005022fc4ce1..4fdc31eaf3991 100644
--- a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingServiceFactory.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingServiceFactory.cs
@@ -10,16 +10,19 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation
     [ExportWorkspaceServiceFactory(typeof(IErrorReportingService), ServiceLayer.Host), Shared]
     internal sealed class VisualStudioErrorReportingServiceFactory : IWorkspaceServiceFactory
     {
-        private readonly IErrorReportingService _singleton;
+        private IErrorReportingService _singleton;
 
         [ImportingConstructor]
-        public VisualStudioErrorReportingServiceFactory(IInfoBarService infoBarService)
+        public VisualStudioErrorReportingServiceFactory()
         {
-            _singleton = new VisualStudioErrorReportingService(infoBarService);
         }
 
         public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
         {
+            if (_singleton == null)
+            {
+                _singleton = new VisualStudioErrorReportingService(workspaceServices.GetRequiredService<IInfoBarService>());
+            }
             return _singleton;
         }
     }

From 4a0eea3bbeef286049c8f9e4ed452e87ce205fcc Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Tue, 9 May 2017 13:20:45 -0700
Subject: [PATCH 072/284] Cleaned up documentation

---
 .../Core/Portable/ExtensionManager/IInfoBarService.cs           | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/Workspaces/Core/Portable/ExtensionManager/IInfoBarService.cs b/src/Workspaces/Core/Portable/ExtensionManager/IInfoBarService.cs
index 789b0a53c87be..de2e3e8b55e26 100644
--- a/src/Workspaces/Core/Portable/ExtensionManager/IInfoBarService.cs
+++ b/src/Workspaces/Core/Portable/ExtensionManager/IInfoBarService.cs
@@ -18,8 +18,6 @@ internal interface IInfoBarService : IWorkspaceService
         /// <summary>
         /// Show global info bar
         /// </summary>
-        /// <param name="message"></param>
-        /// <param name="items"></param>
         void ShowInfoBarInGlobalView(string message, params InfoBarUI[] items);
     }
 

From c6f25f62941c5fbf9c9e024319a305bd3f785482 Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam.harwell@microsoft.com>
Date: Tue, 9 May 2017 14:19:14 -0500
Subject: [PATCH 073/284] Disable test for simplifier edge case

See dotnet/roslyn#19368
---
 .../Test2/Simplification/TypeNameSimplifierTest.vb             | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/Test2/Simplification/TypeNameSimplifierTest.vb b/src/EditorFeatures/Test2/Simplification/TypeNameSimplifierTest.vb
index 32b2f089b013e..0733460a05bed 100644
--- a/src/EditorFeatures/Test2/Simplification/TypeNameSimplifierTest.vb
+++ b/src/EditorFeatures/Test2/Simplification/TypeNameSimplifierTest.vb
@@ -764,7 +764,8 @@ namespace N1
             Await TestAsync(input, expected)
         End Function
 
-        <Fact, Trait(Traits.Feature, Traits.Features.Simplification)>
+        <Fact(Skip:="https://github.com/dotnet/roslyn/issues/19368")>
+        <Trait(Traits.Feature, Traits.Features.Simplification)>
         Public Async Function TestSimplifyNot_Delegate1() As Task
             Dim input =
         <Workspace>

From b4ae4feee48f030b738224b5f772613bb0876b05 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Tue, 9 May 2017 13:27:59 -0700
Subject: [PATCH 074/284] Added missing csproj edits

---
 src/EditorFeatures/Core/EditorFeatures.csproj         | 2 +-
 src/VisualStudio/Core/Def/ServicesVisualStudio.csproj | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/EditorFeatures/Core/EditorFeatures.csproj b/src/EditorFeatures/Core/EditorFeatures.csproj
index 521cb964a62df..c4ca714ba6082 100644
--- a/src/EditorFeatures/Core/EditorFeatures.csproj
+++ b/src/EditorFeatures/Core/EditorFeatures.csproj
@@ -168,7 +168,7 @@
     <Compile Include="Implementation\Structure\BlockTagState.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionSetComparer.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionsSource.cs" />
-    <Compile Include="Implementation\Workspaces\EditorInfoBarService.cs" />
+    <Compile Include="Implementation\InfoBar\EditorInfoBarService.cs" />
     <Compile Include="SymbolSearch\IAddReferenceDatabaseWrapper.cs" />
     <Compile Include="SymbolSearch\IDatabaseFactoryService.cs" />
     <Compile Include="SymbolSearch\IDelayService.cs" />
diff --git a/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj b/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
index bad1214edf92c..4c7b48649bd96 100644
--- a/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
+++ b/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
@@ -168,7 +168,7 @@
     <Compile Include="Implementation\Workspace\VisualStudioErrorReportingService.ExceptionFormatting.cs" />
     <Compile Include="Implementation\Workspace\VisualStudioErrorReportingServiceFactory.cs" />
     <Compile Include="Implementation\Workspace\VisualStudioErrorReportingService.cs" />
-    <Compile Include="Implementation\Workspace\VisualStudioInfoBarService.cs" />
+    <Compile Include="Implementation\InfoBar\VisualStudioInfoBarService.cs" />
     <Compile Include="Implementation\Workspace\VisualStudioNavigationOptions.cs" />
     <Compile Include="Implementation\Workspace\VisualStudioNavigationOptionsProvider.cs" />
     <Compile Include="Implementation\Workspace\VisualStudioProjectCacheHostServiceFactory.cs" />

From c1bfe6f3caea206275af989fd095230ed5677650 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Tue, 9 May 2017 13:47:09 -0700
Subject: [PATCH 075/284] added boost service in service hub

---
 .../Remote/ServiceHub/ServiceHub.csproj       |  1 +
 .../Remote/ServiceHub/UserOperationBooster.cs | 69 +++++++++++++++++++
 2 files changed, 70 insertions(+)
 create mode 100644 src/Workspaces/Remote/ServiceHub/UserOperationBooster.cs

diff --git a/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj b/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj
index 1d5b8a990240a..d6d11f07df18b 100644
--- a/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj
+++ b/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj
@@ -90,6 +90,7 @@
     <Compile Include="Shared\ServerDirectStream.cs" />
     <Compile Include="Shared\ClientDirectStream.cs" />
     <Compile Include="Telemetry\WatsonReporter.cs" />
+    <Compile Include="UserOperationBooster.cs" />
   </ItemGroup>
   <ItemGroup>
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.LiveUnitTesting.BuildManager" />
diff --git a/src/Workspaces/Remote/ServiceHub/UserOperationBooster.cs b/src/Workspaces/Remote/ServiceHub/UserOperationBooster.cs
new file mode 100644
index 0000000000000..cdfd1e14466ad
--- /dev/null
+++ b/src/Workspaces/Remote/ServiceHub/UserOperationBooster.cs
@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Diagnostics;
+using System.Threading;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.Remote
+{
+    /// <summary>
+    /// Boost performance of any servicehub service which is invoked by user explicit actions
+    /// </summary>
+    internal static class UserOperationBooster
+    {
+        private static int s_count = 0;
+
+        public static IDisposable Boost()
+        {
+            return new Booster();
+        }
+
+        private static void Start()
+        {
+            var value = Interlocked.Increment(ref s_count);
+            Contract.Requires(value >= 0);
+
+            if (value == 1)
+            {
+                // boost to normal priority
+                Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.Normal;
+            }
+        }
+
+        private static void Done()
+        {
+            var value = Interlocked.Decrement(ref s_count);
+            Contract.Requires(value >= 0);
+
+            if (value == 0)
+            {
+                // when boost is done, set process back to below normal priority
+                Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.BelowNormal;
+            }
+        }
+
+        private class Booster : IDisposable
+        {
+            public Booster()
+            {
+                Start();
+            }
+
+            public void Dispose()
+            {
+                Done();
+
+                GC.SuppressFinalize(this);
+            }
+
+            ~Booster()
+            {
+                if (!Environment.HasShutdownStarted)
+                {
+                    Contract.Fail($@"Should have been disposed!");
+                }
+            }
+        }
+    }
+}

From 7642cb0211cf0461c885ca4bdc03bcd415fdc06a Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Tue, 9 May 2017 13:47:20 -0700
Subject: [PATCH 076/284] fixed release mode build break

---
 src/Workspaces/Remote/Core/TestUtils.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Remote/Core/TestUtils.cs b/src/Workspaces/Remote/Core/TestUtils.cs
index 8010164270c98..4085a78ecaf4b 100644
--- a/src/Workspaces/Remote/Core/TestUtils.cs
+++ b/src/Workspaces/Remote/Core/TestUtils.cs
@@ -53,7 +53,7 @@ public static Dictionary<Checksum, object> GetAssetMap(this Project project)
         public static void AppendAssetMap(this Solution solution, Dictionary<Checksum, object> map)
         {
             SolutionStateChecksums solutionChecksums;
-            Contract.Requires(solution.State.TryGetStateChecksums(out solutionChecksums));
+            Contract.ThrowIfFalse(solution.State.TryGetStateChecksums(out solutionChecksums));
 
             solutionChecksums.Find(solution.State, Flatten(solutionChecksums), map, CancellationToken.None);
 
@@ -88,7 +88,7 @@ private static void AppendAssetMap(Project project, Dictionary<Checksum, object>
         private static void AppendAssetMap(TextDocument document, Dictionary<Checksum, object> map)
         {
             DocumentStateChecksums documentChecksums;
-            Contract.Requires(document.State.TryGetStateChecksums(out documentChecksums));
+            Contract.ThrowIfFalse(document.State.TryGetStateChecksums(out documentChecksums));
 
             documentChecksums.Find(document.State, Flatten(documentChecksums), map, CancellationToken.None);
 

From 57eca79980cbbfba569e50f72d286d2144cacecb Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 15:01:49 -0700
Subject: [PATCH 077/284] Simplify serialization.

---
 .../Core/Portable/Serialization/ObjectWriter.cs       | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
index 2e4a6b8f8508b..eaf572d8da981 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
@@ -728,7 +728,8 @@ private void WriteObject(object instance, IObjectWritable instanceAsWritableOpt)
                     // don't blow the stack.  'LongRunning' ensures that we get a dedicated thread
                     // to do this work.  That way we don't end up blocking the threadpool.
                     var task = Task.Factory.StartNew(
-                        () => WriteObjectWorker(instance, writable),
+                        obj => WriteObjectWorker((IObjectWritable)obj),
+                        writable,
                         _cancellationToken,
                         TaskCreationOptions.LongRunning,
                         TaskScheduler.Default);
@@ -736,7 +737,7 @@ private void WriteObject(object instance, IObjectWritable instanceAsWritableOpt)
                 }
                 else
                 {
-                    WriteObjectWorker(instance, writable);
+                    WriteObjectWorker(writable);
                 }
 
                 _recursionDepth--;
@@ -744,14 +745,14 @@ private void WriteObject(object instance, IObjectWritable instanceAsWritableOpt)
             }
         }
 
-        private void WriteObjectWorker(object instance, IObjectWritable writable)
+        private void WriteObjectWorker(IObjectWritable writable)
         {
             // emit object header up front
-            this.WriteObjectHeader(instance, 0);
+            this.WriteObjectHeader(writable);
             writable.WriteTo(this);
         }
 
-        private void WriteObjectHeader(object instance, uint memberCount)
+        private void WriteObjectHeader(IObjectWritable instance)
         {
             _objectReferenceMap.Add(instance);
 

From 75c9f0d2b68c648a24a77d74393d66741680e9d7 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 15:03:08 -0700
Subject: [PATCH 078/284] Inline method

---
 .../Core/Portable/Serialization/ObjectWriter.cs       | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
index eaf572d8da981..517218dbb3b7b 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
@@ -748,16 +748,11 @@ private void WriteObject(object instance, IObjectWritable instanceAsWritableOpt)
         private void WriteObjectWorker(IObjectWritable writable)
         {
             // emit object header up front
-            this.WriteObjectHeader(writable);
-            writable.WriteTo(this);
-        }
-
-        private void WriteObjectHeader(IObjectWritable instance)
-        {
-            _objectReferenceMap.Add(instance);
+            _objectReferenceMap.Add(writable);
 
             _writer.Write((byte)EncodingKind.Object);
-            this.WriteKnownType(instance.GetType());
+            this.WriteKnownType(writable.GetType());
+            writable.WriteTo(this);
         }
 
         private static Exception NoSerializationTypeException(string typeName)

From 4644b5bfd2280fdaa58aa47bb3b22b234e42d7ba Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 15:03:56 -0700
Subject: [PATCH 079/284] Inline method

---
 .../Core/Portable/Serialization/ObjectReader.cs          | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
index f0d550fadfc50..50757add9b016 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
@@ -576,17 +576,12 @@ public Type ReadType()
         private Type ReadTypeAfterTag()
             => _binderSnapshot.GetTypeFromId(this.ReadInt32());
 
-        private Func<ObjectReader, object> ReadTypeReader()
-        {
-            _reader.ReadByte();
-            return _binderSnapshot.GetTypeReaderFromId(this.ReadInt32());
-        }
-
         private object ReadObject()
         {
             var id = _objectReferenceMap.GetNextReferenceId();
 
-            var typeReader = this.ReadTypeReader();
+            _reader.ReadByte();
+            var typeReader = _binderSnapshot.GetTypeReaderFromId(this.ReadInt32());
 
             // recursive: read and construct instance immediately from member elements encoding next in the stream
             var instance = typeReader(this);

From 6f1baf8b90cf78233b52614761b4c0b59783a601 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 15:22:39 -0700
Subject: [PATCH 080/284] Write out less data for objects.

---
 src/Compilers/Core/Portable/Serialization/ObjectReader.cs | 3 +--
 src/Compilers/Core/Portable/Serialization/ObjectWriter.cs | 5 ++++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
index 50757add9b016..4e150a112bdff 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
@@ -32,7 +32,7 @@ internal sealed partial class ObjectReader : IDisposable
         /// this version, just change VersionByte2.
         /// </summary>
         internal const byte VersionByte1 = 0b10101010;
-        internal const byte VersionByte2 = 0b00000111;
+        internal const byte VersionByte2 = 0b00001000;
 
         private readonly BinaryReader _reader;
         private readonly CancellationToken _cancellationToken;
@@ -580,7 +580,6 @@ private object ReadObject()
         {
             var id = _objectReferenceMap.GetNextReferenceId();
 
-            _reader.ReadByte();
             var typeReader = _binderSnapshot.GetTypeReaderFromId(this.ReadInt32());
 
             // recursive: read and construct instance immediately from member elements encoding next in the stream
diff --git a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
index 517218dbb3b7b..83a011d143005 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
@@ -751,7 +751,10 @@ private void WriteObjectWorker(IObjectWritable writable)
             _objectReferenceMap.Add(writable);
 
             _writer.Write((byte)EncodingKind.Object);
-            this.WriteKnownType(writable.GetType());
+
+            // Directly write out the type-id for this object.  i.e. no need to write out the 'Type'
+            // tag since we just wrote out the 'Object' tag
+            this.WriteInt32(_binderSnapshot.GetTypeId(writable.GetType()));
             writable.WriteTo(this);
         }
 

From 2d2fed797708cf124efe99349c7850a34794feb8 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 15:26:17 -0700
Subject: [PATCH 081/284] No need to return values here.  They are never used.

---
 src/Compilers/Core/Portable/Serialization/ObjectWriter.cs | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
index 83a011d143005..e10836345435e 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
@@ -319,15 +319,12 @@ public void Dispose()
             }
 
             public bool TryGetReferenceId(object value, out int referenceId)
-            {
-                return _valueToIdMap.TryGetValue(value, out referenceId);
-            }
+                => _valueToIdMap.TryGetValue(value, out referenceId);
 
-            public int Add(object value)
+            public void Add(object value)
             {
                 var id = _nextId++;
                 _valueToIdMap.Add(value, id);
-                return id;
             }
         }
 

From 20f0557760b07680f94a6a6482a7cbb1b53d34ef Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 15:32:55 -0700
Subject: [PATCH 082/284] Make our reference maps less overhead.

---
 .../Portable/Serialization/ObjectReader.cs    | 46 +++++++------------
 .../Portable/Serialization/ObjectWriter.cs    |  6 ++-
 2 files changed, 21 insertions(+), 31 deletions(-)

diff --git a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
index 4e150a112bdff..5d3564f508a02 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
@@ -2,10 +2,8 @@
 
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Diagnostics;
 using System.IO;
-using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -39,9 +37,11 @@ internal sealed partial class ObjectReader : IDisposable
 
         /// <summary>
         /// Map of reference id's to deserialized objects.
+        ///
+        /// These are not readonly because they're structs and we mutate htemthem.
         /// </summary>
-        private readonly ReaderReferenceMap<object> _objectReferenceMap;
-        private readonly ReaderReferenceMap<string> _stringReferenceMap;
+        private ReaderReferenceMap<object> _objectReferenceMap;
+        private ReaderReferenceMap<string> _stringReferenceMap;
 
         /// <summary>
         /// Copy of the global binder data that maps from Types to the appropriate reading-function
@@ -67,8 +67,8 @@ private ObjectReader(
             Debug.Assert(BitConverter.IsLittleEndian);
 
             _reader = new BinaryReader(stream, Encoding.UTF8);
-            _objectReferenceMap = new ReaderReferenceMap<object>();
-            _stringReferenceMap = new ReaderReferenceMap<string>();
+            _objectReferenceMap = ReaderReferenceMap<object>.Create();
+            _stringReferenceMap = ReaderReferenceMap<string>.Create();
 
             // Capture a copy of the current static binder state.  That way we don't have to 
             // access any locks while we're doing our processing.
@@ -227,17 +227,18 @@ private object ReadValueWorker()
         /// <summary>
         /// An reference-id to object map, that can share base data efficiently.
         /// </summary>
-        private class ReaderReferenceMap<T> where T : class
+        private struct ReaderReferenceMap<T> where T : class
         {
             private readonly List<T> _values;
 
             internal static readonly ObjectPool<List<T>> s_objectListPool
                 = new ObjectPool<List<T>>(() => new List<T>(20));
 
-            public ReaderReferenceMap()
-            {
-                _values = s_objectListPool.Allocate();
-            }
+            private ReaderReferenceMap(List<T> values)
+                => _values = values;
+
+            public static ReaderReferenceMap<T> Create()
+                => new ReaderReferenceMap<T>(s_objectListPool.Allocate());
 
             public void Dispose()
             {
@@ -245,21 +246,11 @@ public void Dispose()
                 s_objectListPool.Free(_values);
             }
 
-            public int GetNextReferenceId()
-            {
-                _values.Add(null);
-                return _values.Count - 1;
-            }
-
-            public void SetValue(int referenceId, T value)
-            {
-                _values[referenceId] = value;
-            }
+            public void AddValue(T value)
+                => _values.Add(value);
 
             public T GetValue(int referenceId)
-            {
-                return _values[referenceId];
-            }
+                => _values[referenceId];
         }
 
         internal uint ReadCompressedUInt()
@@ -321,7 +312,6 @@ private string ReadStringValue(EncodingKind kind)
 
         private unsafe string ReadStringLiteral(EncodingKind kind)
         {
-            int id = _stringReferenceMap.GetNextReferenceId();
             string value;
             if (kind == EncodingKind.StringUtf8)
             {
@@ -338,7 +328,7 @@ private unsafe string ReadStringLiteral(EncodingKind kind)
                 }
             }
 
-            _stringReferenceMap.SetValue(id, value);
+            _stringReferenceMap.AddValue(value);
             return value;
         }
 
@@ -578,13 +568,11 @@ private Type ReadTypeAfterTag()
 
         private object ReadObject()
         {
-            var id = _objectReferenceMap.GetNextReferenceId();
-
             var typeReader = _binderSnapshot.GetTypeReaderFromId(this.ReadInt32());
 
             // recursive: read and construct instance immediately from member elements encoding next in the stream
             var instance = typeReader(this);
-            _objectReferenceMap.SetValue(id, instance);
+            _objectReferenceMap.AddValue(instance);
             return instance;
         }
 
diff --git a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
index e10836345435e..db26312aa2032 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
@@ -32,9 +32,11 @@ internal sealed partial class ObjectWriter : IDisposable
         /// Map of serialized object's reference ids.  The object-reference-map uses reference equality
         /// for performance.  While the string-reference-map uses value-equality for greater cache hits 
         /// and reuse.
+        /// 
+        /// These are not readonly because they're structs and we mutate htemthem.
         /// </summary>
-        private readonly WriterReferenceMap _objectReferenceMap;
-        private readonly WriterReferenceMap _stringReferenceMap;
+        private WriterReferenceMap _objectReferenceMap;
+        private WriterReferenceMap _stringReferenceMap;
 
         /// <summary>
         /// Copy of the global binder data that maps from Types to the appropriate reading-function

From ba6b8b105d52abd7bb3126f714f58951de485f68 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 15:36:34 -0700
Subject: [PATCH 083/284] Fix spelling

---
 src/Compilers/Core/Portable/Serialization/ObjectReader.cs | 2 +-
 src/Compilers/Core/Portable/Serialization/ObjectWriter.cs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
index 5d3564f508a02..6183edf5cfefd 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
@@ -38,7 +38,7 @@ internal sealed partial class ObjectReader : IDisposable
         /// <summary>
         /// Map of reference id's to deserialized objects.
         ///
-        /// These are not readonly because they're structs and we mutate htemthem.
+        /// These are not readonly because they're structs and we mutate them.
         /// </summary>
         private ReaderReferenceMap<object> _objectReferenceMap;
         private ReaderReferenceMap<string> _stringReferenceMap;
diff --git a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
index db26312aa2032..9150ae232eec2 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
@@ -33,7 +33,7 @@ internal sealed partial class ObjectWriter : IDisposable
         /// for performance.  While the string-reference-map uses value-equality for greater cache hits 
         /// and reuse.
         /// 
-        /// These are not readonly because they're structs and we mutate htemthem.
+        /// These are not readonly because they're structs and we mutate them.
         /// </summary>
         private WriterReferenceMap _objectReferenceMap;
         private WriterReferenceMap _stringReferenceMap;

From c920455ca95adf61f7b29d6750d1067cad8a7dea Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 15:39:19 -0700
Subject: [PATCH 084/284] Actually make into a struct.

---
 src/Compilers/Core/Portable/Serialization/ObjectWriter.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
index 9150ae232eec2..c8d0c4a3b15b6 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
@@ -281,7 +281,7 @@ private void WriteEncodedUInt32(uint v)
         /// <summary>
         /// An object reference to reference-id map, that can share base data efficiently.
         /// </summary>
-        private class WriterReferenceMap
+        private struct WriterReferenceMap
         {
             private readonly Dictionary<object, int> _valueToIdMap;
             private readonly bool _valueEquality;

From 230d93532f3f2a54732aa9e25326a46f733ff234 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 15:39:51 -0700
Subject: [PATCH 085/284] Simplify

---
 src/Compilers/Core/Portable/Serialization/ObjectWriter.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
index c8d0c4a3b15b6..0617573a56b9c 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
@@ -296,12 +296,12 @@ private struct WriterReferenceMap
             public WriterReferenceMap(bool valueEquality)
             {
                 _valueEquality = valueEquality;
-                _valueToIdMap = GetDictionaryPool().Allocate();
+                _valueToIdMap = GetDictionaryPool(valueEquality).Allocate();
                 _nextId = 0;
             }
 
-            private ObjectPool<Dictionary<object, int>> GetDictionaryPool()
-                => _valueEquality ? s_valueDictionaryPool : s_referenceDictionaryPool;
+            private static ObjectPool<Dictionary<object, int>> GetDictionaryPool(bool valueEquality)
+                => valueEquality ? s_valueDictionaryPool : s_referenceDictionaryPool;
 
             public void Dispose()
             {

From 7551ad2b3f3b18a83be7626cc9f3b84af00654b4 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 15:40:16 -0700
Subject: [PATCH 086/284] Fix code.

---
 src/Compilers/Core/Portable/Serialization/ObjectWriter.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
index 0617573a56b9c..f97466d36672d 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
@@ -305,7 +305,7 @@ private static ObjectPool<Dictionary<object, int>> GetDictionaryPool(bool valueE
 
             public void Dispose()
             {
-                var pool = GetDictionaryPool();
+                var pool = GetDictionaryPool(_valueEquality);
 
                 // If the map grew too big, don't return it to the pool.
                 // When testing with the Roslyn solution, this dropped only 2.5% of requests.

From 38925ac96f71b1d1bcbf9a5b548a80341033cc14 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 15:44:57 -0700
Subject: [PATCH 087/284] Adding comment.

---
 .../Core/Portable/Serialization/ObjectWriter.cs   | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
index f97466d36672d..8630d34a541da 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectWriter.cs
@@ -34,6 +34,21 @@ internal sealed partial class ObjectWriter : IDisposable
         /// and reuse.
         /// 
         /// These are not readonly because they're structs and we mutate them.
+        /// 
+        /// When we write out objects/strings we give each successive, unique, item a monotonically 
+        /// increasing integral ID starting at 0.  I.e. the first object gets ID-0, the next gets 
+        /// ID-1 and so on and so forth.  We do *not* include these IDs with the object when it is
+        /// written out.  We only include the ID if we hit the object *again* while writing.
+        /// 
+        /// During reading, the reader knows to give each object it reads the same monotonically 
+        /// increasing integral value.  i.e. the first object it reads is put into an array at position
+        /// 0, the next at position 1, and so on.  Then, when the reader reads in an object-reference
+        /// it can just retrieved it directly from that array.
+        /// 
+        /// In other words, writing and reading take advantage of the fact that they know they will
+        /// write and read objects in the exact same order.  So they only need the IDs for references
+        /// and not the objects themselves because the ID is inferred from the order the object is
+        /// written or read in.
         /// </summary>
         private WriterReferenceMap _objectReferenceMap;
         private WriterReferenceMap _stringReferenceMap;

From 9b9f11b24274a8a5ba472a100d93dbd7ff3b76b9 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 16:38:18 -0700
Subject: [PATCH 088/284] Use-throw-expression should not be offered when the
 'if-block' has additional statements in it.

---
 .../UseThrowExpressionTests.cs                | 42 +++++++++++++++++++
 ...actUseThrowExpressionDiagnosticAnalyzer.cs | 18 ++++++++
 2 files changed, 60 insertions(+)

diff --git a/src/EditorFeatures/CSharpTest/UseThrowExpression/UseThrowExpressionTests.cs b/src/EditorFeatures/CSharpTest/UseThrowExpression/UseThrowExpressionTests.cs
index a393d7e4a5b2c..96b96345e7ed8 100644
--- a/src/EditorFeatures/CSharpTest/UseThrowExpression/UseThrowExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/UseThrowExpression/UseThrowExpressionTests.cs
@@ -386,6 +386,48 @@ public C(int? x)
 
         _x = x;
     }
+}");
+        }
+
+        [WorkItem(19377, "https://github.com/dotnet/roslyn/issues/19377")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseThrowExpression)]
+        public async Task TestNotWithMultipleStatementsInIf1()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void M(string s)
+    {
+        if (s == null)
+        {
+            Console.WriteLine();
+            [|throw|] new ArgumentNullException(nameof(s));
+        }
+        _s = s;
+    }
+}");
+        }
+
+        [WorkItem(19377, "https://github.com/dotnet/roslyn/issues/19377")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseThrowExpression)]
+        public async Task TestNotWithMultipleStatementsInIf2()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void M(string s)
+    {
+        if (s == null)
+        {
+            [|throw|] new ArgumentNullException(nameof(s));
+            Console.WriteLine();
+        }
+        _s = s;
+    }
 }");
         }
     }
diff --git a/src/Features/Core/Portable/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs b/src/Features/Core/Portable/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
index 8ae3cc4d1674a..a0c92f5d6c605 100644
--- a/src/Features/Core/Portable/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/Core/Portable/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
@@ -116,6 +116,12 @@ private void AnalyzeOperation(OperationAnalysisContext context, INamedTypeSymbol
                 return;
             }
 
+            if (!IsOnlyStatementOfIf(ifOperation, throwOperation))
+            {
+                // The if-statement can only have a single throw-statement in it.
+                return;
+            }
+
             var containingBlock = GetOperation(
                 semanticModel, ifOperation.Syntax.Parent, cancellationToken) as IBlockStatement;
             if (containingBlock == null)
@@ -189,6 +195,18 @@ private void AnalyzeOperation(OperationAnalysisContext context, INamedTypeSymbol
             }
         }
 
+        private bool IsOnlyStatementOfIf(IIfStatement ifOperation, IThrowStatement throwStatement)
+        {
+            if (ifOperation.IfTrueStatement.Syntax == throwStatement.Syntax)
+            {
+                return true;
+            }
+
+            return ifOperation.IfTrueStatement is IBlockStatement block &&
+                   block.Statements.Length == 1 &&
+                   block.Statements[0].Syntax == throwStatement.Syntax;
+        }
+
         protected abstract ISyntaxFactsService GetSyntaxFactsService();
         protected abstract ISemanticFactsService GetSemanticFactsService();
 

From b3495e9c7147d28c0f81cfd5fa58b517caaeedf6 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 16:51:57 -0700
Subject: [PATCH 089/284] Restore logic.

---
 .../Portable/Serialization/ObjectReader.cs     | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
index 6183edf5cfefd..ea876f3ffbefc 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
@@ -246,9 +246,20 @@ public void Dispose()
                 s_objectListPool.Free(_values);
             }
 
+
+            public int GetNextObjectId()
+            {
+                var id = _values.Count;
+                _values.Add(null);
+                return id;
+            }
+
             public void AddValue(T value)
                 => _values.Add(value);
 
+            public void AddValue(int index, T value)
+                => _values[index] = value;
+
             public T GetValue(int referenceId)
                 => _values[referenceId];
         }
@@ -568,11 +579,16 @@ private Type ReadTypeAfterTag()
 
         private object ReadObject()
         {
+            var objectId = _objectReferenceMap.GetNextObjectId();
+
+            // reading an object may recurse.  So we need to grab our ID up front as we'll
+            // end up making our sub-objects before we make this object.
+
             var typeReader = _binderSnapshot.GetTypeReaderFromId(this.ReadInt32());
 
             // recursive: read and construct instance immediately from member elements encoding next in the stream
             var instance = typeReader(this);
-            _objectReferenceMap.AddValue(instance);
+            _objectReferenceMap.AddValue(objectId, instance);
             return instance;
         }
 

From a7ca8fd0fe286a7bd5415d400c23bbb6554f251a Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 17:32:44 -0700
Subject: [PATCH 090/284] Formatting.

---
 src/Compilers/Core/Portable/Serialization/ObjectReader.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
index ea876f3ffbefc..ae696efa9ac69 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
@@ -607,4 +607,4 @@ private static Exception NoSerializationReaderException(string typeName)
             return new InvalidOperationException(string.Format(Resources.Cannot_serialize_type_0, typeName));
         }
     }
-}
+}
\ No newline at end of file

From 969b5cb1be9e60269b735c9fad135d66e4f566ad Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 9 May 2017 17:33:19 -0700
Subject: [PATCH 091/284] Simplify code.

---
 src/Compilers/Core/Portable/Serialization/IObjectWritable.cs | 2 +-
 src/Compilers/Core/Portable/Serialization/ObjectBinder.cs    | 2 --
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/Compilers/Core/Portable/Serialization/IObjectWritable.cs b/src/Compilers/Core/Portable/Serialization/IObjectWritable.cs
index a5c494ff6d7bb..77956a643abf8 100644
--- a/src/Compilers/Core/Portable/Serialization/IObjectWritable.cs
+++ b/src/Compilers/Core/Portable/Serialization/IObjectWritable.cs
@@ -10,4 +10,4 @@ internal interface IObjectWritable
     {
         void WriteTo(ObjectWriter writer);
     }
-}
+}
\ No newline at end of file
diff --git a/src/Compilers/Core/Portable/Serialization/ObjectBinder.cs b/src/Compilers/Core/Portable/Serialization/ObjectBinder.cs
index 59821dd731bcc..d3fcc95b5d182 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectBinder.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectBinder.cs
@@ -2,8 +2,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
 
 namespace Roslyn.Utilities
 {

From 9364b8c6c0320da0c99c9a0642185992da43108e Mon Sep 17 00:00:00 2001
From: Alireza Habibi <habibi.alireza@outlook.com>
Date: Wed, 10 May 2017 17:46:52 +0430
Subject: [PATCH 092/284] PR feedback

---
 .../ConvertNumericLiteral/ConvertNumericLiteralTests.vb         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb b/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb
index b38d228341454..d3810bad590af 100644
--- a/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb
@@ -109,7 +109,7 @@ End Class",
             &B1, &H2
         }
     End Sub
-End Class", index := Refactoring.ChangeBase2, ignoreTrivia := False)
+End Class", index:=Refactoring.ChangeBase2, ignoreTrivia:=False)
         End Function
     End Class
 End Namespace

From cc4ea4693cf28b60daf31113c680bdbd55d081cb Mon Sep 17 00:00:00 2001
From: Ty Overby <ty@pre-alpha.com>
Date: Wed, 10 May 2017 09:41:55 -0700
Subject: [PATCH 093/284] Entrypoint detection stages (#19093)

* simplify partial method return type syntax finder tests

* Bug fixes and API use changes

* address first review

* better comment and compiler trait on class

* fix tests, pull entrypoint check out into local function

* unify diagnostics for intvoid or task mains

* add more tests, change error text

* address review

* finish tests

* be explicit on language version in tests

* add another test, fix typo, add diagnostics even when they aren't likely to exist

* rewrite error->warning code, add more cases to tests

* change test language versions

* formatting on comments and adding WithLocation to tests

* fix formatting for some tests

* fix some formatting and added withlocation

* fix withlocation
---
 .../CSharp/Portable/Binder/Binder_Symbols.cs  |   9 +-
 .../Portable/CSharpResources.Designer.cs      |  29 +-
 .../CSharp/Portable/CSharpResources.resx      |   6 +-
 .../Portable/Compilation/CSharpCompilation.cs | 129 +++--
 .../CSharp/Portable/Errors/ErrorCode.cs       |   2 +-
 .../SynthesizedEntryPointSymbol.cs            |   1 -
 .../Emit/CodeGen/CodeGenAsyncMainTests.cs     | 459 +++++++++++++++---
 .../Semantic/Semantics/BindingAsyncTests.cs   |  10 +-
 .../Test/Symbol/Symbols/Source/MethodTests.cs |  23 +-
 .../Portable/Traits/CompilerFeature.cs        |   1 +
 10 files changed, 520 insertions(+), 149 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
index d02e32d22e28e..2cc61856e9e13 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
@@ -2060,12 +2060,12 @@ private AssemblySymbol GetForwardedToAssembly(string fullName, int arity, Diagno
             return null;
         }
 
-        internal static void CheckFeatureAvailability(SyntaxNode syntax, MessageID feature, DiagnosticBag diagnostics, Location locationOpt = null)
+        internal static bool CheckFeatureAvailability(SyntaxNode syntax, MessageID feature, DiagnosticBag diagnostics, Location locationOpt = null)
         {
             var options = (CSharpParseOptions)syntax.SyntaxTree.Options;
             if (options.IsFeatureEnabled(feature))
             {
-                return;
+                return true;
             }
 
             var location = locationOpt ?? syntax.GetLocation();
@@ -2073,7 +2073,7 @@ internal static void CheckFeatureAvailability(SyntaxNode syntax, MessageID featu
             if (requiredFeature != null)
             {
                 diagnostics.Add(ErrorCode.ERR_FeatureIsExperimental, location, feature.Localize(), requiredFeature);
-                return;
+                return false;
             }
 
             LanguageVersion availableVersion = options.LanguageVersion;
@@ -2081,7 +2081,10 @@ internal static void CheckFeatureAvailability(SyntaxNode syntax, MessageID featu
             if (requiredVersion > availableVersion)
             {
                 diagnostics.Add(availableVersion.GetErrorCode(), location, feature.Localize(), new CSharpRequiredLanguageVersion(requiredVersion));
+                return false;
             }
+
+            return true;
         }
     }
 }
\ No newline at end of file
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
index 1280b1141bdb8..de6e009a64bba 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
+++ b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
@@ -6882,7 +6882,18 @@ internal static string ERR_NonInvocableMemberCalled {
                 return ResourceManager.GetString("ERR_NonInvocableMemberCalled", resourceCulture);
             }
         }
-        
+
+        /// <summary>
+        ///   Looks up a localized string similar to Async Main methods must return Task or Task&lt;int&gt;.
+        /// </summary>
+        internal static string ERR_NonTaskMainCantBeAsync
+        {
+            get
+            {
+                return ResourceManager.GetString("ERR_NonTaskMainCantBeAsync", resourceCulture);
+            }
+        }
+
         /// <summary>
         ///   Looks up a localized string similar to Cannot embed interop types from assembly &apos;{0}&apos; because it is missing the &apos;{1}&apos; attribute..
         /// </summary>
@@ -9852,22 +9863,24 @@ internal static string IDS_Covariantly {
                 return ResourceManager.GetString("IDS_Covariantly", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to 
         ///                              Visual C# Compiler Options
         ///
         ///                        - OUTPUT FILES -
-        /// /out:&lt;file&gt;                   Specify output file name (default: base name of 
+        /// /out:&lt;file&gt;                   Specify output file name (default: base name of
         ///                               file with main class or first file)
-        /// /target:exe                   Build a console executable (default) (Short 
+        /// /target:exe                   Build a console executable (default) (Short
         ///                               form: /t:exe)
-        /// /target:winexe                Build a Windows executable (Short form: 
+        /// /target:winexe                Build a Windows executable (Short form:
         ///                               /t:winexe)
-        /// /target:library     [rest of string was truncated]&quot;;.
+        /// /target:library        [rest of string was truncated]&quot;;.
         /// </summary>
-        internal static string IDS_CSCHelp {
-            get {
+        internal static string IDS_CSCHelp
+        {
+            get
+            {
                 return ResourceManager.GetString("IDS_CSCHelp", resourceCulture);
             }
         }
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index 78bf4e6b5f7b5..82afbcaa4e07b 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -3596,9 +3596,6 @@ Give the compiler some way to differentiate the methods. For example, you can gi
   <data name="ERR_SecurityCriticalOrSecuritySafeCriticalOnAsyncInClassOrStruct" xml:space="preserve">
     <value>Async methods are not allowed in an Interface, Class, or Structure which has the 'SecurityCritical' or 'SecuritySafeCritical' attribute.</value>
   </data>
-  <data name="ERR_MainCantBeAsync" xml:space="preserve">
-    <value>'{0}': an entry point cannot be marked with the 'async' modifier</value>
-  </data>
   <data name="ERR_BadAwaitInQuery" xml:space="preserve">
     <value>The 'await' operator may only be used in a query expression within the first collection expression of the initial 'from' clause or within the collection expression of a 'join' clause</value>
   </data>
@@ -5073,4 +5070,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_VoidInTuple" xml:space="preserve">
     <value>A tuple may not contain a value of type 'void'.</value>
   </data>
+  <data name="ERR_NonTaskMainCantBeAsync" xml:space="preserve">
+    <value>A void or int returning entry point cannot be async</value>
+  </data>
 </root>
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index c1dada07c57d0..9e078424051a2 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
@@ -1453,42 +1453,101 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
                     }
                 }
 
-                DiagnosticBag warnings = DiagnosticBag.GetInstance();
-                var viableEntryPoints = ArrayBuilder<MethodSymbol>.GetInstance();
-                foreach (var candidate in entryPointCandidates)
+                // Validity and diagnostics are also tracked because they must be conditionally handled
+                // if there are not any "traditional" entrypoints found.
+                var taskEntryPoints = ArrayBuilder<(bool IsValid, MethodSymbol Candidate, DiagnosticBag SpecificDiagnostics)>.GetInstance();
+
+                // These diagnostics (warning only) are added to the compilation only if
+                // there were not any main methods found.
+                DiagnosticBag noMainFoundDiagnostics = DiagnosticBag.GetInstance();
+
+                bool CheckValid(MethodSymbol candidate, bool isCandidate, DiagnosticBag specificDiagnostics)
                 {
-                    if (!HasEntryPointSignature(candidate, warnings))
+                    if (!isCandidate)
                     {
-                        // a single error for partial methods
-                        warnings.Add(ErrorCode.WRN_InvalidMainSig, candidate.Locations.First(), candidate);
-                        continue;
+                        noMainFoundDiagnostics.Add(ErrorCode.WRN_InvalidMainSig, candidate.Locations.First(), candidate);
+                        noMainFoundDiagnostics.AddRange(specificDiagnostics);
+                        return false;
                     }
 
                     if (candidate.IsGenericMethod || candidate.ContainingType.IsGenericType)
                     {
                         // a single error for partial methods:
-                        warnings.Add(ErrorCode.WRN_MainCantBeGeneric, candidate.Locations.First(), candidate);
-                        continue;
+                        noMainFoundDiagnostics.Add(ErrorCode.WRN_MainCantBeGeneric, candidate.Locations.First(), candidate);
+                        return false;
                     }
+                    return true;
+                }
+
+                var viableEntryPoints = ArrayBuilder<MethodSymbol>.GetInstance();
+
+                foreach (var candidate in entryPointCandidates)
+                {
+                    var perCandidateBag = DiagnosticBag.GetInstance();
+                    var (IsCandidate, IsTaskLike) = HasEntryPointSignature(candidate, perCandidateBag);
 
-                    // PROTOTYPE(async-main): CheckFeatureAvailability should be called on non-async methods 
-                    // that return Task or Task<T>
-                    if (candidate.IsAsync)
+                    if (IsTaskLike)
                     {
-                        // PROTOTYPE(async-main): Get the diagnostic to point to a smaller syntax piece.
-                        // PROTOTYPE(async-main): Switch diagnostics around if the type is not Task or Task<T>
-                        CheckFeatureAvailability(candidate.GetNonNullSyntaxNode(), MessageID.IDS_FeatureAsyncMain, diagnostics);
+                        taskEntryPoints.Add((IsCandidate, candidate, perCandidateBag));
+                    }
+                    else
+                    {
+                        if (CheckValid(candidate, IsCandidate, perCandidateBag))
+                        {
+                            if (candidate.IsAsync)
+                            {
+                                diagnostics.Add(ErrorCode.ERR_NonTaskMainCantBeAsync, candidate.Locations.First(), candidate);
+                            }
+                            else
+                            {
+                                diagnostics.AddRange(perCandidateBag);
+                                viableEntryPoints.Add(candidate);
+                            }
+                        }
+                        perCandidateBag.Free();
                     }
+                }
 
-                    viableEntryPoints.Add(candidate);
+                if (viableEntryPoints.Count == 0)
+                {
+                    foreach (var (IsValid, Candidate, SpecificDiagnostics) in taskEntryPoints)
+                    {
+                        // PROTOTYPE(async-main): Get the diagnostic to point to a smaller syntax piece.
+                        if (CheckValid(Candidate, IsValid, SpecificDiagnostics) &&
+                            CheckFeatureAvailability(Candidate.GetNonNullSyntaxNode(), MessageID.IDS_FeatureAsyncMain, diagnostics))
+                        {
+                            diagnostics.AddRange(SpecificDiagnostics);
+                            viableEntryPoints.Add(Candidate);
+                        }
+                    }
                 }
 
-                if ((object)mainType == null || viableEntryPoints.Count == 0)
+                foreach (var (_, _, SpecificDiagnostics) in taskEntryPoints)
                 {
-                    diagnostics.AddRange(warnings);
+                    SpecificDiagnostics.Free();
                 }
 
-                warnings.Free();
+                if (viableEntryPoints.Count == 0)
+                {
+                    diagnostics.AddRange(noMainFoundDiagnostics);
+                }
+                else if ((object)mainType == null)
+                {
+                    // Filters out diagnostics so that only InvalidMainSig and MainCant'BeGeneric are left.
+                    // The reason that Error diagnostics can end up in `noMainFoundDiagnostics` is when
+                    // HasEntryPointSignature yields some Error Diagnostics when people implement Task or Task<T> incorrectly.
+                    //
+                    // We can't add those Errors to the general diagnostics bag because it would break previously-working programs.
+                    // The fact that these warnings are not added when csc is invoked with /main is possibly a bug, and is tracked at
+                    // https://github.com/dotnet/roslyn/issues/18964
+                    foreach (var diagnostic in noMainFoundDiagnostics.AsEnumerable())
+                    {
+                        if (diagnostic.Code == (int)ErrorCode.WRN_InvalidMainSig || diagnostic.Code == (int)ErrorCode.WRN_MainCantBeGeneric)
+                        {
+                            diagnostics.Add(diagnostic);
+                        }
+                    }
+                }
 
                 MethodSymbol entryPoint = null;
                 if (viableEntryPoints.Count == 0)
@@ -1518,7 +1577,9 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
                     entryPoint = viableEntryPoints[0];
                 }
 
+                taskEntryPoints.Free();
                 viableEntryPoints.Free();
+                noMainFoundDiagnostics.Free();
                 return entryPoint;
             }
             finally
@@ -1561,15 +1622,16 @@ internal bool ReturnsAwaitableToVoidOrInt(MethodSymbol method, DiagnosticBag dia
 
         /// <summary>
         /// Checks if the method has an entry point compatible signature, i.e.
-        /// - the return type is either void, int, <see cref="System.Threading.Tasks.Task" />,
-        /// or <see cref="System.Threading.Tasks.Task{T}" /> where T is an int.
+        /// - the return type is either void, int, or returns a <see cref="System.Threading.Tasks.Task" />,
+        /// or <see cref="System.Threading.Tasks.Task{T}" /> where the return type of GetAwaiter().GetResult()
+        /// is either void or int.
         /// - has either no parameter or a single parameter of type string[]
         /// </summary>
-        private bool HasEntryPointSignature(MethodSymbol method, DiagnosticBag bag)
+        private (bool IsCandidate, bool IsTaskLike) HasEntryPointSignature(MethodSymbol method, DiagnosticBag bag)
         {
             if (method.IsVararg)
             {
-                return false;
+                return (false, false);
             }
 
             TypeSymbol returnType = method.ReturnType;
@@ -1580,45 +1642,38 @@ private bool HasEntryPointSignature(MethodSymbol method, DiagnosticBag bag)
                 returnsTaskOrTaskOfInt = ReturnsAwaitableToVoidOrInt(method, bag);
                 if (!returnsTaskOrTaskOfInt)
                 {
-                    return false;
+                    return (false, false);
                 }
             }
 
-            // Prior to 7.1, async methods were considered to "have the entrypoint signature".
-            // In order to keep back-compat, we need to let these through if compiling using a previous language version.
-            if (!returnsTaskOrTaskOfInt && method.IsAsync && this.LanguageVersion >= LanguageVersion.CSharp7_1)
-            {
-                return false;
-            }
-
             if (method.RefKind != RefKind.None)
             {
-                return false;
+                return (false, returnsTaskOrTaskOfInt);
             }
 
             if (method.Parameters.Length == 0)
             {
-                return true;
+                return (true, returnsTaskOrTaskOfInt);
             }
 
             if (method.Parameters.Length > 1)
             {
-                return false;
+                return (false, returnsTaskOrTaskOfInt);
             }
 
             if (!method.ParameterRefKinds.IsDefault)
             {
-                return false;
+                return (false, returnsTaskOrTaskOfInt);
             }
 
             var firstType = method.Parameters[0].Type;
             if (firstType.TypeKind != TypeKind.Array)
             {
-                return false;
+                return (false, returnsTaskOrTaskOfInt);
             }
 
             var array = (ArrayTypeSymbol)firstType;
-            return array.IsSZArray && array.ElementType.SpecialType == SpecialType.System_String;
+            return (array.IsSZArray && array.ElementType.SpecialType == SpecialType.System_String, returnsTaskOrTaskOfInt);
         }
 
         internal override bool IsUnreferencedAssemblyIdentityDiagnosticCode(int code)
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index cdaf5879c9e2a..ea7ce6b4a38fd 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -1104,7 +1104,7 @@ internal enum ErrorCode
         ERR_VarargsAsync = 4006,
         ERR_ByRefTypeAndAwait = 4007,
         ERR_BadAwaitArgVoidCall = 4008,
-        // ERR_MainCantBeAsync = 4009,
+        ERR_NonTaskMainCantBeAsync = 4009,
         ERR_CantConvAsyncAnonFuncReturns = 4010,
         ERR_BadAwaiterPattern = 4011,
         ERR_BadSpecialByRefLocal = 4012,
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
index 58187a5827b59..826b6d3ae3d80 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
@@ -388,7 +388,6 @@ internal override BoundBlock CreateBody()
             {
                 var syntax = _userMainReturnTypeSyntax;
 
-
                 if (ReturnsVoid)
                 {
                     return new BoundBlock(
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMainTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMainTests.cs
index 3dd02d4548495..fbaae3a50786b 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMainTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMainTests.cs
@@ -3,14 +3,15 @@
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Xunit;
 using System.Threading;
+using Microsoft.CodeAnalysis.Test.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests.CodeGen
 {
+    [CompilerTrait(CompilerFeature.AsyncMain)]
     public class CodeGenAsyncMainTests : EmitMetadataTestBase
     {
-
         [Fact]
-        public void MultipleMainsOneOfWhichHasBadTaskType_WithMainType()
+        public void MultipleMainsOneOfWhichHasBadTaskType_CSharp71_WithMainType()
         {
             var source = @"
 using System.Threading.Tasks;
@@ -35,7 +36,7 @@ static void Main(string[] args) { }
         }
 
         [Fact]
-        public void MultipleMainsOneOfWhichHasBadTaskType()
+        public void MultipleMainsOneOfWhichHasBadTaskType_CSharp7()
         {
             var source = @"
 using System.Threading.Tasks;
@@ -52,21 +53,114 @@ static Task<int> Main() {
     }
     static void Main(string[] args) { }
 }";
-            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
             sourceCompilation.VerifyEmitDiagnostics(
                 // (11,12): warning CS0436: The type 'Task<T>' in '' conflicts with the imported type 'Task<TResult>' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
                 //     static Task<int> Main() {
                 Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task<int>").WithArguments("", "System.Threading.Tasks.Task<T>", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task<TResult>").WithLocation(11, 12),
-                // (11,12): error CS1986: 'await' requires that the type Task<int> have a suitable GetAwaiter method
+                // (11,22): warning CS0028: 'Program.Main()' has the wrong signature to be an entry point
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main()").WithLocation(11, 22));
+        }
+
+        [Fact]
+        public void MultipleMainsOneOfWhichHasBadTaskType_CSharp7_WithExplicitMain()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+namespace System.Threading.Tasks {
+    public class Task<T> {
+        public void GetAwaiter() {}
+    }
+}
+
+static class Program {
+    static Task<int> Main() {
+        return null;
+    }
+    static void Main(string[] args) { }
+}";
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe.WithMainTypeName("Program"), parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            sourceCompilation.VerifyEmitDiagnostics(
+                // (11,12): warning CS0436: The type 'Task<T>' in '' conflicts with the imported type 'Task<TResult>' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
                 //     static Task<int> Main() {
-                Diagnostic(ErrorCode.ERR_BadAwaitArg, "Task<int>").WithArguments("System.Threading.Tasks.Task<int>").WithLocation(11, 12),
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task<int>").WithArguments("", "System.Threading.Tasks.Task<T>", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task<TResult>").WithLocation(11, 12));
+        }
+
+        [Fact]
+        public void MultipleMainsOneOfWhichHasBadTaskType_CSharp71()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+namespace System.Threading.Tasks {
+    public class Task<T> {
+        public void GetAwaiter() {}
+    }
+}
+
+static class Program {
+    static Task<int> Main() {
+        return null;
+    }
+    static void Main(string[] args) { }
+}";
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            sourceCompilation.VerifyEmitDiagnostics(
+                // (11,12): warning CS0436: The type 'Task<T>' in '' conflicts with the imported type 'Task<TResult>' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task<int>").WithArguments("", "System.Threading.Tasks.Task<T>", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task<TResult>").WithLocation(11, 12),
                 // (11,22): warning CS0028: 'Program.Main()' has the wrong signature to be an entry point
                 //     static Task<int> Main() {
                 Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main()").WithLocation(11, 22));
         }
 
         [Fact]
-        public void GetResultReturnsSomethingElse()
+        public void GetResultReturnsSomethingElse_CSharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+using System;
+
+namespace System.Runtime.CompilerServices {
+    public interface INotifyCompletion {
+        void OnCompleted(Action action);
+    }
+}
+
+namespace System.Threading.Tasks {
+    public class Awaiter: System.Runtime.CompilerServices.INotifyCompletion {
+        public double GetResult() { return 0.0; }
+        public bool IsCompleted  => true;
+        public void OnCompleted(Action action) {}
+    }
+    public class Task<T> {
+        public Awaiter GetAwaiter() {
+            return new Awaiter();
+        }
+    }
+}
+
+static class Program {
+    static Task<int> Main() {
+        return null;
+    }
+}";
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            sourceCompilation.VerifyEmitDiagnostics(
+                // (25,12): warning CS0436: The type 'Task<T>' in '' conflicts with the imported type 'Task<TResult>' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task<int>").WithArguments("", "System.Threading.Tasks.Task<T>", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task<TResult>").WithLocation(25, 12),
+                // (25,22): warning CS0028: 'Program.Main()' has the wrong signature to be an entry point
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main()").WithLocation(25, 22),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void GetResultReturnsSomethingElse_CSharp71()
         {
             var source = @"
 using System.Threading.Tasks;
@@ -105,12 +199,48 @@ static Task<int> Main() {
                 //     static Task<int> Main() {
                 Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main()").WithLocation(25, 22),
                 // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
-                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1)
-);
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
         }
 
         [Fact]
-        public void TaskOfTGetAwaiterReturnsVoid()
+        public void TaskOfTGetAwaiterReturnsVoid_CSharp7()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+namespace System.Threading.Tasks {
+    public class Task<T> {
+        public void GetAwaiter() {}
+    }
+}
+
+static class Program {
+    static Task<int> Main() {
+        return null;
+    }
+}";
+
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            sourceCompilation.VerifyDiagnostics(
+                // (12,12): warning CS0436: The type 'Task<T>' in '' conflicts with the imported type 'Task<TResult>' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task<int>").WithArguments("", "System.Threading.Tasks.Task<T>", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task<TResult>").WithLocation(12, 12),
+                // (12,12): error CS1986: 'await' requires that the type Task<int> have a suitable GetAwaiter method
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.ERR_BadAwaitArg, "Task<int>").WithArguments("System.Threading.Tasks.Task<int>").WithLocation(12, 12),
+                // (12,22): warning CS0028: 'Program.Main()' has the wrong signature to be an entry point
+                //     static Task<int> Main() {
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("Program.Main()").WithLocation(12, 22),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1),
+                // (2,1): hidden CS8019: Unnecessary using directive.
+                // using System;
+                Diagnostic(ErrorCode.HDN_UnusedUsingDirective, "using System;").WithLocation(2, 1));
+        }
+
+        [Fact]
+        public void TaskOfTGetAwaiterReturnsVoid_CSharp71()
         {
             var source = @"
 using System;
@@ -145,6 +275,7 @@ static Task<int> Main() {
                 // using System;
                 Diagnostic(ErrorCode.HDN_UnusedUsingDirective, "using System;").WithLocation(2, 1));
         }
+
         [Fact]
         public void TaskGetAwaiterReturnsVoid()
         {
@@ -215,6 +346,8 @@ public void EmitTaskOfIntReturningMainWithoutInt()
             var corAssembly = @"
 namespace System {
     public class Object {}
+    public abstract class ValueType{}
+    public struct Int32{}
 }";
             var corCompilation = CreateCompilation(corAssembly, options: TestOptions.DebugDll);
             corCompilation.VerifyDiagnostics();
@@ -241,9 +374,6 @@ static Task<int> Main() {
                 Diagnostic(ErrorCode.WRN_NoRuntimeMetadataVersion).WithLocation(1, 1),
                 // (6,17): error CS0518: Predefined type 'System.Int32' is not defined or imported
                 //     static Task<int> Main() {
-                Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "int").WithArguments("System.Int32").WithLocation(6, 17),
-                // (6,12): error CS1061: 'Task<int>' does not contain a definition for 'GetAwaiter' and no extension method 'GetAwaiter' accepting a first argument of type 'Task<int>' could be found (are you missing a using directive or an assembly reference?)
-                //     static Task<int> Main() {
                 Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "Task<int>").WithArguments("System.Threading.Tasks.Task<int>", "GetAwaiter").WithLocation(6, 12),
                 // (6,22): warning CS0028: 'Program.Main()' has the wrong signature to be an entry point
                 //     static Task<int> Main() {
@@ -292,26 +422,6 @@ static Task Main() {
                 Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
         }
 
-        [Fact]
-        public void AsyncEmitMainOfIntTest()
-        {
-            var source = @"
-using System;
-using System.Threading.Tasks;
-
-class Program {
-    static async Task<int> Main() {
-        Console.Write(""hello "");
-        await Task.Factory.StartNew(() => 5);
-        Console.Write(""async main"");
-        return 10;
-    }
-}";
-            var c = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
-            var verifier = CompileAndVerify(c, expectedOutput: "hello async main", expectedReturnCode: 10);
-
-        }
-
         [Fact]
         public void AsyncEmitMainTest()
         {
@@ -548,6 +658,8 @@ async static Task Main(string[] args)
 }";
             var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
             compilation.VerifyDiagnostics(
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1),
                 // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
                 //     async static Task Main(string[] args)
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task Main(string[] args)
@@ -596,7 +708,7 @@ static Task Main()
         }
 
         [Fact]
-        public void MainCantBeAsyncVoid()
+        public void MainCantBeAsyncVoid_CSharp7()
         {
             var source = @"
 using System.Threading.Tasks;
@@ -608,38 +720,13 @@ async static void Main()
         await Task.Factory.StartNew(() => { });
     }
 }";
-            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
             compilation.VerifyDiagnostics(
-                // (6,23): warning CS0028: 'A.Main()' has the wrong signature to be an entry point
+                // (6,23): error CS9003: Async Main methods must return Task or Task<int>
                 //     async static void Main()
-                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main()").WithLocation(6, 23),
+                Diagnostic(ErrorCode.ERR_NonTaskMainCantBeAsync, "Main").WithArguments("A.Main()").WithLocation(6, 23),
                 // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
                 Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
-            var entry = compilation.GetEntryPoint(CancellationToken.None);
-            Assert.Null(entry);
-        }
-
-        [Fact]
-        public void MainCantBeAsyncVoid_CSharp7()
-        {
-            var source = @"
-using System.Threading.Tasks;
-
-class A
-{
-    async static void Main()
-    {
-        await Task.Factory.StartNew(() => { });
-    }
-}";
-            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
-            compilation.VerifyDiagnostics(
-            // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
-            //     async static void Main()
-            Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static void Main()
-    {
-        await Task.Factory.StartNew(() => { });
-    }").WithArguments("async main", "7.1").WithLocation(6, 5));
         }
 
         [Fact]
@@ -660,9 +747,9 @@ async static int Main()
                 // (6,22): error CS1983: The return type of an async method must be void, Task or Task<T>
                 //     async static int Main()
                 Diagnostic(ErrorCode.ERR_BadAsyncReturn, "Main").WithLocation(6, 22),
-                // (6,23): warning CS0028: 'A.Main()' has the wrong signature to be an entry point
-                //     async static void Main()
-                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main()").WithLocation(6, 22),
+                // (6,22): error CS4009: A void or int returning entry point cannot be async
+                //     async static int Main()
+                Diagnostic(ErrorCode.ERR_NonTaskMainCantBeAsync, "Main").WithArguments("A.Main()").WithLocation(6, 22),
                 // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
                 Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
             var entry = compilation.GetEntryPoint(CancellationToken.None);
@@ -686,14 +773,12 @@ async static int Main()
             compilation.VerifyDiagnostics(
                 // (6,22): error CS1983: The return type of an async method must be void, Task or Task<T>
                 //     async static int Main()
-                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "Main"),
-                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "Main").WithLocation(6, 22),
+                // (6,22): error CS9003: Async Main methods must return Task or Task<int>
                 //     async static int Main()
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static int Main()
-    {
-        return await Task.Factory.StartNew(() => 5);
-    }").WithArguments("async main", "7.1").WithLocation(6, 5)
-);
+                Diagnostic(ErrorCode.ERR_NonTaskMainCantBeAsync, "Main").WithArguments("A.Main()").WithLocation(6, 22),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
         }
 
         [Fact]
@@ -751,13 +836,14 @@ async static Task<int> Main(string[] args)
 }";
             var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
             compilation.VerifyDiagnostics(
+            // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+            Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1),
             // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
             //     async static Task<int> Main(string[] args)
             Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task<int> Main(string[] args)
     {
         return await Task.Factory.StartNew(() => 5);
-    }").WithArguments("async main", "7.1").WithLocation(6, 5)
-);
+    }").WithArguments("async main", "7.1").WithLocation(6, 5));
         }
 
         [Fact]
@@ -779,6 +865,7 @@ async static Task<int> Main()
             Assert.NotNull(entry);
             Assert.Equal("System.Threading.Tasks.Task<System.Int32> A.Main()", entry.ToTestDisplayString());
         }
+
         [Fact]
         public void MainCanReturnTaskAndGenericOnInt_NoAsync()
         {
@@ -819,8 +906,9 @@ async static Task<int> Main()
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task<int> Main()
     {
         return await Task.Factory.StartNew(() => 5);
-    }").WithArguments("async main", "7.1").WithLocation(6, 5)
-                );
+    }").WithArguments("async main", "7.1").WithLocation(6, 5),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
         }
 
         [Fact]
@@ -860,9 +948,9 @@ async static void Main<T>()
     }
 }";
             CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1)).VerifyDiagnostics(
-                // (6,23): warning CS0028: 'A.Main<T>()' has the wrong signature to be an entry point
+                // (6,23): warning CS0402: 'A.Main<T>()': an entry point cannot be generic or in a generic type
                 //     async static void Main<T>()
-                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main<T>()").WithLocation(6, 23),
+                Diagnostic(ErrorCode.WRN_MainCantBeGeneric, "Main").WithArguments("A.Main<T>()").WithLocation(6, 23),
                 // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
                 Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
         }
@@ -908,5 +996,220 @@ async static void Main<T>(bool truth)
                 // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
                 Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
         }
+
+        [Fact]
+        public void TaskMainAndNonTaskMain()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static void Main()
+    {
+        System.Console.WriteLine(""Non Task Main"");
+    }
+    async static Task Main(string[] args)
+    {
+        await Task.Factory.StartNew(() => { });
+        System.Console.WriteLine(""Task Main"");
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7)).VerifyDiagnostics();
+            CompileAndVerify(compilation, expectedOutput: "Non Task Main", expectedReturnCode: 0);
+        }
+
+        [Fact]
+        public void TaskMainAndNonTaskMain_CSharp71()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static void Main()
+    {
+        System.Console.WriteLine(""Non Task Main"");
+    }
+    async static Task Main(string[] args)
+    {
+        await Task.Factory.StartNew(() => { });
+        System.Console.WriteLine(""Task Main"");
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1)).VerifyDiagnostics();
+            CompileAndVerify(compilation, expectedOutput: "Non Task Main", expectedReturnCode: 0);
+        }
+
+        [Fact]
+        public void AsyncVoidMain_CSharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static void Main(string[] args)
+    {
+        await Task.Factory.StartNew(() => { });
+        System.Console.WriteLine(""Async Void Main"");
+    }
+    async static int Main()
+    {
+        await Task.Factory.StartNew(() => { });
+        System.Console.WriteLine(""Async Void Main"");
+        return 1;
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe).VerifyDiagnostics(
+                // (11,22): error CS1983: The return type of an async method must be void, Task or Task<T>
+                //     async static int Main()
+                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "Main").WithLocation(11, 22),
+                // (11,22): error CS4009: A void or int returning entry point cannot be async
+                //     async static int Main()
+                Diagnostic(ErrorCode.ERR_NonTaskMainCantBeAsync, "Main").WithArguments("A.Main()").WithLocation(11, 22),
+                // (6,23): error CS4009: A void or int returning entry point cannot be async
+                //     async static void Main(string[] args)
+                Diagnostic(ErrorCode.ERR_NonTaskMainCantBeAsync, "Main").WithArguments("A.Main(string[])").WithLocation(6, 23),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void AsyncVoidMain_CSharp71()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static async void Main(string[] args)
+    {
+        await Task.Factory.StartNew(() => { });
+        System.Console.WriteLine(""Async Void Main"");
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1)).VerifyDiagnostics(
+                // (6,23): error CS4009: A void or int returning entry point cannot be async
+                //     static async void Main(string[] args)
+                Diagnostic(ErrorCode.ERR_NonTaskMainCantBeAsync, "Main").WithArguments("A.Main(string[])").WithLocation(6, 23),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void TaskMainAndNonTaskMain_WithExplicitMain()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static void Main()
+    {
+        System.Console.WriteLine(""Non Task Main"");
+    }
+    async static Task Main(string[] args)
+    {
+        await Task.Factory.StartNew(() => { });
+        System.Console.WriteLine(""Task Main"");
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe.WithMainTypeName("A")).VerifyDiagnostics();
+            CompileAndVerify(compilation, expectedOutput: "Non Task Main", expectedReturnCode: 0);
+        }
+
+        [Fact]
+        public void TaskIntAndTaskFloat_CSharp7()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    async static Task<int> Main()
+    {
+        System.Console.WriteLine(""Task<int>"");
+        return 0;
+    }
+
+    async static Task<float> Main(string[] args)
+    {
+        System.Console.WriteLine(""Task<float>"");
+        return 0.0F;
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseDebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7)).VerifyDiagnostics(
+                // (6,28): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
+                //     async static Task<int> Main()
+                Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "Main").WithLocation(6, 28),
+                // (12,30): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
+                //     async static Task<float> Main(string[] args)
+                Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "Main").WithLocation(12, 30),
+                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     async static Task<int> Main()
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task<int> Main()
+    {
+        System.Console.WriteLine(""Task<int>"");
+        return 0;
+    }").WithArguments("async main", "7.1").WithLocation(6, 5),
+                // (12,30): warning CS0028: 'A.Main(string[])' has the wrong signature to be an entry point
+                //     async static Task<float> Main(string[] args)
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main(string[])").WithLocation(12, 30),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+
+        [Fact]
+        public void TaskOfFloatMainAndNonTaskMain()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static void Main()
+    {
+        System.Console.WriteLine(""Non Task Main"");
+    }
+
+    async static Task<float> Main(string[] args)
+    {
+        await Task.Factory.StartNew(() => { });
+        System.Console.WriteLine(""Task Main"");
+        return 0.0f;
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe).VerifyDiagnostics(
+                // (10,30): warning CS0028: 'A.Main(string[])' has the wrong signature to be an entry point
+                //     async static Task<float> Main(string[] args)
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main(string[])").WithLocation(11, 30));
+                CompileAndVerify(compilation, expectedOutput: "Non Task Main", expectedReturnCode: 0);
+        }
+
+        [Fact]
+        public void TaskOfFloatMainAndNonTaskMain_WithExplicitMain()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static void Main()
+    {
+        System.Console.WriteLine(""Non Task Main"");
+    }
+
+    async static Task<float> Main(string[] args)
+    {
+        await Task.Factory.StartNew(() => { });
+        System.Console.WriteLine(""Task Main"");
+        return 0.0f;
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe.WithMainTypeName("A")).VerifyDiagnostics();
+            CompileAndVerify(compilation, expectedOutput: "Non Task Main", expectedReturnCode: 0);
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs
index ea6c34daf69c4..b5ceade1893ea 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs
@@ -3403,7 +3403,7 @@ public static int Main()
         }
 
         [Fact, WorkItem(547081, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/547081")]
-        public void Repro_17885()
+        public void Repro_17885_CSharp_71()
         {
             var source = @"
 using System.Threading.Tasks;
@@ -3416,7 +3416,7 @@ async public static Task Main()
             CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1)).VerifyDiagnostics(
                 // (5,30): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
                 //     async public static Task Main()
-                Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "Main"));
+                Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "Main").WithLocation(5, 30));
         }
 
         [Fact, WorkItem(547081, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/547081")]
@@ -3433,12 +3433,14 @@ async public static Task Main()
             CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7)).VerifyDiagnostics(
                 // (5,30): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
                 //     async public static Task Main()
-                Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "Main"),
+                Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "Main").WithLocation(5, 30),
                 // (5,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
                 //     async public static Task Main()
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async public static Task Main()
     {
-    }").WithArguments("async main", "7.1").WithLocation(5, 5));
+    }").WithArguments("async main", "7.1").WithLocation(5, 5),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
         }
 
         [Fact, WorkItem(547088, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/547088")]
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/MethodTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/MethodTests.cs
index e0b17fba31631..7b9c0c19250a6 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/MethodTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/MethodTests.cs
@@ -5,6 +5,7 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.Text;
@@ -222,12 +223,10 @@ partial void M() {}
             var returnSyntax = m.ExtractReturnTypeSyntax();
 
             var tree = comp.SyntaxTrees.Single();
-            var model = comp.GetSemanticModel(tree);
-            var voidTokens = tree.GetRoot().DescendantTokens().Where(t => t.Kind() == SyntaxKind.VoidKeyword).ToList();
-            var node = tree.GetRoot().FindNode(voidTokens[0].Span);
+            var node = tree.GetRoot().DescendantNodes().OfType<PredefinedTypeSyntax>().Where(n => n.Keyword.Kind() == SyntaxKind.VoidKeyword).First();
 
-            var mLocations = tree.GetRoot().DescendantTokens().Where(t => t.ValueText == "M").ToList();
-            var otherSymbol = (MethodSymbol)model.GetDeclaredSymbolForNode(tree.GetRoot().FindNode(mLocations[1].Span));
+            var otherSymbol = m.PartialImplementationPart;
+            Assert.True(otherSymbol.IsPartialImplementation());
 
             Assert.Equal(node, returnSyntax);
             Assert.Equal(node, otherSymbol.ExtractReturnTypeSyntax());
@@ -252,12 +251,10 @@ public partial class A {
             var returnSyntax = m.ExtractReturnTypeSyntax();
 
             var tree = comp.SyntaxTrees.Single();
-            var model = comp.GetSemanticModel(tree);
-            var token = tree.GetRoot().DescendantTokens().Where(t => t.Kind() == SyntaxKind.VoidKeyword).Skip(1).First();
-            var node = tree.GetRoot().FindNode(token.Span);
+            var node = tree.GetRoot().DescendantNodes().OfType<PredefinedTypeSyntax>().Where(n => n.Keyword.Kind() == SyntaxKind.VoidKeyword).Last();
 
-            var mLocations = tree.GetRoot().DescendantTokens().Where(t => t.ValueText == "M").ToList();
-            var otherSymbol = (MethodSymbol)model.GetDeclaredSymbolForNode(tree.GetRoot().FindNode(mLocations[0].Span));
+            var otherSymbol = m.PartialImplementationPart;
+            Assert.True(otherSymbol.IsPartialImplementation());
 
             Assert.Equal(node, returnSyntax);
             Assert.Equal(node, otherSymbol.ExtractReturnTypeSyntax());
@@ -279,8 +276,7 @@ partial void M() {}
             var returnSyntax = m.ExtractReturnTypeSyntax();
 
             var tree = comp.SyntaxTrees.Single().GetRoot();
-            var token = tree.DescendantTokens().Where(t => t.Kind() == SyntaxKind.VoidKeyword).First();
-            var node = tree.FindNode(token.Span);
+            var node = tree.DescendantNodes().OfType<PredefinedTypeSyntax>().Where(n => n.Keyword.Kind() == SyntaxKind.VoidKeyword).Single();
 
             Assert.Equal(node, returnSyntax);
         }
@@ -301,8 +297,7 @@ public void PartialExtractSyntaxLocation_OnlyDecl()
             var returnSyntax = m.ExtractReturnTypeSyntax();
 
             var tree = comp.SyntaxTrees.Single().GetRoot();
-            var token = tree.DescendantTokens().Where(t => t.Kind() == SyntaxKind.VoidKeyword).First();
-            var node = tree.FindNode(token.Span);
+            var node = tree.DescendantNodes().OfType<PredefinedTypeSyntax>().Where(n => n.Keyword.Kind() == SyntaxKind.VoidKeyword).Single();
 
             Assert.Equal(node, returnSyntax);
         }
diff --git a/src/Test/Utilities/Portable/Traits/CompilerFeature.cs b/src/Test/Utilities/Portable/Traits/CompilerFeature.cs
index e3ac493c97775..0530fb6217152 100644
--- a/src/Test/Utilities/Portable/Traits/CompilerFeature.cs
+++ b/src/Test/Utilities/Portable/Traits/CompilerFeature.cs
@@ -20,5 +20,6 @@ public enum CompilerFeature
         OutVar,
         Patterns,
         DefaultLiteral,
+        AsyncMain,
     }
 }

From 124865bf9b87e71972e7af9ca278385ac1a6a529 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Wed, 10 May 2017 09:46:36 -0700
Subject: [PATCH 094/284] updated following PR feedback

---
 .../Core/Next/Remote/JsonRpcSession.cs        | 10 ++-
 .../Execution/PinnedRemotableDataScope.cs     |  5 +-
 .../Remote/Core/RemoteWorkspaces.csproj       |  1 +
 .../Core/Services/ISolutionController.cs      | 17 ++++
 .../Remote/Core/Services/SolutionService.cs   | 84 +++++++++++--------
 .../ServiceHub/Services/RemoteHostService.cs  |  3 +-
 .../Shared/ServiceHubServiceBase.cs           | 24 ++++--
 7 files changed, 97 insertions(+), 47 deletions(-)
 create mode 100644 src/Workspaces/Remote/Core/Services/ISolutionController.cs

diff --git a/src/VisualStudio/Core/Next/Remote/JsonRpcSession.cs b/src/VisualStudio/Core/Next/Remote/JsonRpcSession.cs
index 5ce8f5f5472f7..49c560ffadd06 100644
--- a/src/VisualStudio/Core/Next/Remote/JsonRpcSession.cs
+++ b/src/VisualStudio/Core/Next/Remote/JsonRpcSession.cs
@@ -86,13 +86,17 @@ private JsonRpcSession(
 
         private async Task InitializeAsync()
         {
-            // all roslyn remote service must based on ServiceHubServiceBase which implements Initialize method
+            // All roslyn remote service must based on ServiceHubServiceBase which implements Initialize method
+            // This will set this session's solution and whether that solution is for primary branch or not
+            var primaryBranch = PinnedScopeOpt?.ForPrimaryBranch ?? false;
+            var solutionChecksum = PinnedScopeOpt?.SolutionChecksum;
+
             if (_snapshotClientOpt != null)
             {
-                await _snapshotClientOpt.InvokeAsync(WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, _currentSessionId, PinnedScopeOpt.Primary, PinnedScopeOpt.SolutionChecksum).ConfigureAwait(false);
+                await _snapshotClientOpt.InvokeAsync(WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, _currentSessionId, primaryBranch, solutionChecksum).ConfigureAwait(false);
             }
 
-            await _serviceClient.InvokeAsync(WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, _currentSessionId, PinnedScopeOpt?.Primary ?? false, PinnedScopeOpt?.SolutionChecksum).ConfigureAwait(false);
+            await _serviceClient.InvokeAsync(WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, _currentSessionId, primaryBranch, solutionChecksum).ConfigureAwait(false);
         }
 
         public override Task InvokeAsync(string targetName, params object[] arguments)
diff --git a/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs b/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs
index b318627aacac8..f09b9ada783c5 100644
--- a/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs
+++ b/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs
@@ -33,7 +33,10 @@ public PinnedRemotableDataScope(
             _storages.RegisterSnapshot(this, storage);
         }
 
-        public bool Primary => _storage.SolutionState.BranchId == Workspace.PrimaryBranchId;
+        /// <summary>
+        /// This indicates whether this scope is for primary branch or not (not forked solution)
+        /// </summary>
+        public bool ForPrimaryBranch => _storage.SolutionState.BranchId == Workspace.PrimaryBranchId;
 
         public Workspace Workspace => _storage.SolutionState.Workspace;
 
diff --git a/src/Workspaces/Remote/Core/RemoteWorkspaces.csproj b/src/Workspaces/Remote/Core/RemoteWorkspaces.csproj
index 3790331862d61..8d74222e4ee66 100644
--- a/src/Workspaces/Remote/Core/RemoteWorkspaces.csproj
+++ b/src/Workspaces/Remote/Core/RemoteWorkspaces.csproj
@@ -70,6 +70,7 @@
     <Compile Include="Services\AssetStorage.cs" />
     <Compile Include="Services\ChecksumSynchronizer.cs" />
     <Compile Include="Services\CompilationService.cs" />
+    <Compile Include="Services\ISolutionController.cs" />
     <Compile Include="Services\ProjectCacheHostServiceFactory.cs" />
     <Compile Include="Services\RoslynServices.cs" />
     <Compile Include="Services\SolutionCreator.cs" />
diff --git a/src/Workspaces/Remote/Core/Services/ISolutionController.cs b/src/Workspaces/Remote/Core/Services/ISolutionController.cs
new file mode 100644
index 0000000000000..c84e03f5ed9ef
--- /dev/null
+++ b/src/Workspaces/Remote/Core/Services/ISolutionController.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.CodeAnalysis.Remote
+{
+    /// <summary>
+    /// Engine use this to set or update solution for given session (connection)
+    /// </summary>
+    internal interface ISolutionController
+    {
+        Task<Solution> GetSolutionAsync(Checksum solutionChecksum, bool fromPrimaryBranch, CancellationToken cancellationToken);
+
+        Task UpdatePrimaryWorkspaceAsync(Checksum solutionChecksum, CancellationToken cancellationToken);
+    }
+}
diff --git a/src/Workspaces/Remote/Core/Services/SolutionService.cs b/src/Workspaces/Remote/Core/Services/SolutionService.cs
index c9dd90db2359d..0a2019cb24af7 100644
--- a/src/Workspaces/Remote/Core/Services/SolutionService.cs
+++ b/src/Workspaces/Remote/Core/Services/SolutionService.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
-using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 using Roslyn.Utilities;
@@ -13,7 +12,7 @@ namespace Microsoft.CodeAnalysis.Remote
     /// 
     /// TODO: change this to workspace service
     /// </summary>
-    internal class SolutionService
+    internal class SolutionService : ISolutionController
     {
         private static readonly SemaphoreSlim s_gate = new SemaphoreSlim(initialCount: 1);
         private static readonly RemoteWorkspace s_primaryWorkspace = new RemoteWorkspace();
@@ -31,13 +30,12 @@ public SolutionService(AssetService assetService)
 
         public Task<Solution> GetSolutionAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
         {
-            return GetSolutionAsync(solutionChecksum, primary: false, cancellationToken: cancellationToken);
+            // this method is called by users which means we don't know whether the solution is from primary branch or not.
+            // so we will be conservative and assume it is not. meaning it won't update any internal caches but only consume cache if possible.
+            return GetSolutionInternalAsync(solutionChecksum, fromPrimaryBranch: false, cancellationToken: cancellationToken);
         }
 
-        /// <summary>
-        /// This should be only consumed by engine, not by user.
-        /// </summary>
-        public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, bool primary, CancellationToken cancellationToken)
+        private async Task<Solution> GetSolutionInternalAsync(Checksum solutionChecksum, bool fromPrimaryBranch, CancellationToken cancellationToken)
         {
             var currentSolution = GetAvailableSolution(solutionChecksum);
             if (currentSolution != null)
@@ -54,65 +52,77 @@ public async Task<Solution> GetSolutionAsync(Checksum solutionChecksum, bool pri
                     return currentSolution;
                 }
 
-                var solution = await CreateSolution_NoLockAsync(solutionChecksum, primary, s_primaryWorkspace.CurrentSolution, cancellationToken).ConfigureAwait(false);
+                var solution = await CreateSolution_NoLockAsync(solutionChecksum, fromPrimaryBranch, s_primaryWorkspace.CurrentSolution, cancellationToken).ConfigureAwait(false);
                 s_lastSolution = Tuple.Create(solutionChecksum, solution);
 
                 return solution;
             }
         }
 
-        /// <summary>
-        /// This should be only consumed by engine, not by user.
-        /// </summary>
-        public async Task UpdatePrimaryWorkspaceAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
-        {
-            var currentSolution = s_primaryWorkspace.CurrentSolution;
-
-            var primarySolutionChecksum = await currentSolution.State.GetChecksumAsync(cancellationToken).ConfigureAwait(false);
-            if (primarySolutionChecksum == solutionChecksum)
-            {
-                return;
-            }
-
-            using (await s_gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
-            {
-                var primary = true;
-                var solution = await CreateSolution_NoLockAsync(solutionChecksum, primary, currentSolution, cancellationToken).ConfigureAwait(false);
-                s_primarySolution = Tuple.Create(solutionChecksum, solution);
-            }
-        }
-
-        private async Task<Solution> CreateSolution_NoLockAsync(Checksum solutionChecksum, bool primary, Solution baseSolution, CancellationToken cancellationToken)
+        private async Task<Solution> CreateSolution_NoLockAsync(Checksum solutionChecksum, bool fromPrimaryBranch, Solution baseSolution, CancellationToken cancellationToken)
         {
             var updater = new SolutionCreator(_assetService, baseSolution, cancellationToken);
 
+            // check whether solution is update to the given base solution
             if (await updater.IsIncrementalUpdateAsync(solutionChecksum).ConfigureAwait(false))
             {
-                // solution has updated
-                if (primary)
+                // create updated solution off the baseSolution
+                var solution = await updater.CreateSolutionAsync(solutionChecksum).ConfigureAwait(false);
+
+                if (fromPrimaryBranch)
                 {
-                    s_primaryWorkspace.UpdateSolution(await updater.CreateSolutionAsync(solutionChecksum).ConfigureAwait(false));
+                    // if the solutionChecksum is for primary branch, update primary workspace cache with the solution
+                    s_primaryWorkspace.UpdateSolution(solution);
                     return s_primaryWorkspace.CurrentSolution;
                 }
 
-                return await updater.CreateSolutionAsync(solutionChecksum).ConfigureAwait(false);
+                // otherwise, just return the solution
+                return solution;
             }
 
-            // new solution. bulk sync all asset for the solution
+            // we need new solution. bulk sync all asset for the solution first.
             await _assetService.SynchronizeSolutionAssetsAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
 
-            if (primary)
+            // get new solution info
+            var solutionInfo = await updater.CreateSolutionInfoAsync(solutionChecksum).ConfigureAwait(false);
+
+            if (fromPrimaryBranch)
             {
+                // if the solutionChecksum is for primary branch, update primary workspace cache with new solution
                 s_primaryWorkspace.ClearSolution();
-                s_primaryWorkspace.AddSolution(await updater.CreateSolutionInfoAsync(solutionChecksum).ConfigureAwait(false));
+                s_primaryWorkspace.AddSolution(solutionInfo);
 
                 return s_primaryWorkspace.CurrentSolution;
             }
 
+            // otherwise, just return new solution
             var workspace = new TemporaryWorkspace(await updater.CreateSolutionInfoAsync(solutionChecksum).ConfigureAwait(false));
             return workspace.CurrentSolution;
         }
 
+        async Task<Solution> ISolutionController.GetSolutionAsync(Checksum solutionChecksum, bool primary, CancellationToken cancellationToken)
+        {
+            return await GetSolutionInternalAsync(solutionChecksum, primary, cancellationToken).ConfigureAwait(false);
+        }
+
+        async Task ISolutionController.UpdatePrimaryWorkspaceAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
+        {
+            var currentSolution = s_primaryWorkspace.CurrentSolution;
+
+            var primarySolutionChecksum = await currentSolution.State.GetChecksumAsync(cancellationToken).ConfigureAwait(false);
+            if (primarySolutionChecksum == solutionChecksum)
+            {
+                return;
+            }
+
+            using (await s_gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
+            {
+                var primary = true;
+                var solution = await CreateSolution_NoLockAsync(solutionChecksum, primary, currentSolution, cancellationToken).ConfigureAwait(false);
+                s_primarySolution = Tuple.Create(solutionChecksum, solution);
+            }
+        }
+
         private static Solution GetAvailableSolution(Checksum solutionChecksum)
         {
             var currentSolution = s_primarySolution;
diff --git a/src/Workspaces/Remote/ServiceHub/Services/RemoteHostService.cs b/src/Workspaces/Remote/ServiceHub/Services/RemoteHostService.cs
index 35449361371ce..3adee6306e184 100644
--- a/src/Workspaces/Remote/ServiceHub/Services/RemoteHostService.cs
+++ b/src/Workspaces/Remote/ServiceHub/Services/RemoteHostService.cs
@@ -81,7 +81,8 @@ public async Task SynchronizePrimaryWorkspaceAsync(Checksum checksum)
             {
                 try
                 {
-                    await RoslynServices.SolutionService.UpdatePrimaryWorkspaceAsync(checksum, CancellationToken).ConfigureAwait(false);
+                    var solutionController = (ISolutionController)RoslynServices.SolutionService;
+                    await solutionController.UpdatePrimaryWorkspaceAsync(checksum, CancellationToken).ConfigureAwait(false);
                 }
                 catch (IOException)
                 {
diff --git a/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs b/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs
index 051a27624a059..a02a3ca22f613 100644
--- a/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs
+++ b/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs
@@ -5,7 +5,6 @@
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.VisualStudio.LanguageServices.Remote;
 using Roslyn.Utilities;
 using StreamJsonRpc;
@@ -27,9 +26,22 @@ internal abstract class ServiceHubServiceBase : IDisposable
         protected readonly AssetStorage AssetStorage;
         protected readonly CancellationToken CancellationToken;
 
+        /// <summary>
+        /// Session Id of this service. caller and callee share this id which one
+        /// can use to find matching caller and callee when debugging or logging
+        /// </summary>
         private int _sessionId;
-        private bool _primary;
+
+        /// <summary>
+        /// Mark whether the solution checksum it got is for primary branch or not
+        /// </summary>
+        private bool _fromPrimaryBranch;
+
+        /// <summary>
+        /// solution this connection belong to
+        /// </summary>
         private Checksum _solutionChecksumOpt;
+
         private RoslynServices _lazyRoslynServices;
 
         [Obsolete("For backward compatibility. this will be removed once all callers moved to new ctor")]
@@ -91,7 +103,9 @@ protected RoslynServices RoslynServices
         protected Task<Solution> GetSolutionAsync()
         {
             Contract.ThrowIfNull(_solutionChecksumOpt);
-            return RoslynServices.SolutionService.GetSolutionAsync(_solutionChecksumOpt, _primary, CancellationToken);
+
+            var solutionController = (ISolutionController)RoslynServices.SolutionService;
+            return solutionController.GetSolutionAsync(_solutionChecksumOpt, _fromPrimaryBranch, CancellationToken);
         }
 
         protected virtual void Dispose(bool disposing)
@@ -104,11 +118,11 @@ protected void LogError(string message)
             Log(TraceEventType.Error, message);
         }
 
-        public virtual void Initialize(int sessionId, bool primary, Checksum solutionChecksum)
+        public virtual void Initialize(int sessionId, bool fromPrimaryBranch, Checksum solutionChecksum)
         {
             // set session related information
             _sessionId = sessionId;
-            _primary = primary;
+            _fromPrimaryBranch = fromPrimaryBranch;
 
             if (solutionChecksum != null)
             {

From f67bfae237fba950c0cc8732a31e81daba5bf539 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Wed, 10 May 2017 10:53:20 -0700
Subject: [PATCH 095/284] fix build break and add test

---
 .../Core/Test.Next/Remote/JsonConverterTests.cs      | 12 ++++++++++++
 .../Core/Test.Next/Services/SolutionServiceTests.cs  | 10 +++++-----
 2 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/src/VisualStudio/Core/Test.Next/Remote/JsonConverterTests.cs b/src/VisualStudio/Core/Test.Next/Remote/JsonConverterTests.cs
index a98e79f19e12f..782fcae33614c 100644
--- a/src/VisualStudio/Core/Test.Next/Remote/JsonConverterTests.cs
+++ b/src/VisualStudio/Core/Test.Next/Remote/JsonConverterTests.cs
@@ -25,6 +25,18 @@ public void TestChecksum()
             VerifyJsonSerialization(new Checksum(Guid.NewGuid().ToByteArray()));
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
+        public void TestChecksum_Null()
+        {
+            VerifyJsonSerialization<Checksum>(null);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
+        public void TestChecksumNull()
+        {
+            VerifyJsonSerialization(Checksum.Null);
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
         public void TestSolutionId()
         {
diff --git a/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs b/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
index 0d5aaf3a39ad7..17fdd709da3b1 100644
--- a/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
+++ b/src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs
@@ -60,8 +60,8 @@ public async Task TestGetSolutionWithPrimaryFlag()
                 var solution = workspace.CurrentSolution;
                 var solutionChecksum = await solution.State.GetChecksumAsync(CancellationToken.None);
 
-                var service = await GetSolutionServiceAsync(solution);
-                var synched = await service.GetSolutionAsync(solutionChecksum, primary: true, cancellationToken: CancellationToken.None);
+                var service = (ISolutionController)await GetSolutionServiceAsync(solution);
+                var synched = await service.GetSolutionAsync(solutionChecksum, fromPrimaryBranch: true, cancellationToken: CancellationToken.None);
                 Assert.Equal(solutionChecksum, await synched.State.GetChecksumAsync(CancellationToken.None));
                 Assert.True(synched.Workspace is RemoteWorkspace);
             }
@@ -278,7 +278,7 @@ public async Task TestRemoteWorkspaceSolutionCrawler()
 
                 // update primary workspace
                 var solutionChecksum = await solution.State.GetChecksumAsync(CancellationToken.None);
-                await service.UpdatePrimaryWorkspaceAsync(solutionChecksum, CancellationToken.None);
+                await ((ISolutionController)service).UpdatePrimaryWorkspaceAsync(solutionChecksum, CancellationToken.None);
 
                 // get solution in remote host
                 var oopSolution = await service.GetSolutionAsync(solutionChecksum, CancellationToken.None);
@@ -326,7 +326,7 @@ private static async Task VerifySolutionUpdate(TestWorkspace workspace, Func<Sol
             var solutionChecksum = await solution.State.GetChecksumAsync(CancellationToken.None);
 
             // update primary workspace
-            await service.UpdatePrimaryWorkspaceAsync(solutionChecksum, CancellationToken.None);
+            await ((ISolutionController)service).UpdatePrimaryWorkspaceAsync(solutionChecksum, CancellationToken.None);
             var first = await service.GetSolutionAsync(solutionChecksum, CancellationToken.None);
 
             Assert.Equal(solutionChecksum, await first.State.GetChecksumAsync(CancellationToken.None));
@@ -344,7 +344,7 @@ private static async Task VerifySolutionUpdate(TestWorkspace workspace, Func<Sol
             Assert.False(object.ReferenceEquals(PrimaryWorkspace.Workspace.PrimaryBranchId, second.BranchId));
 
             // do same once updating primary workspace
-            await service.UpdatePrimaryWorkspaceAsync(newSolutionChecksum, CancellationToken.None);
+            await ((ISolutionController)service).UpdatePrimaryWorkspaceAsync(newSolutionChecksum, CancellationToken.None);
             var third = await service.GetSolutionAsync(newSolutionChecksum, CancellationToken.None);
 
             Assert.Equal(newSolutionChecksum, await third.State.GetChecksumAsync(CancellationToken.None));

From 1cbe2ce2b0eb9edc9022ffd8a69e65586570f499 Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Wed, 10 May 2017 10:53:27 -0700
Subject: [PATCH 096/284] Re-enable roslyn analyzers on Roslyn.sln and update
 public api file for an IOperation API change merged yesterday (#19278).

---
 build/Targets/Packages.props                        | 2 +-
 build/Targets/Settings.props                        | 2 +-
 src/Compilers/Core/Portable/PublicAPI.Unshipped.txt | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/build/Targets/Packages.props b/build/Targets/Packages.props
index 638af15a836ae..3350acfec27bf 100644
--- a/build/Targets/Packages.props
+++ b/build/Targets/Packages.props
@@ -47,7 +47,7 @@
     <MicrosoftMSXMLVersion>8.0.0.0-alpha</MicrosoftMSXMLVersion>
     <MicrosoftNetCompilersVersion>2.0.1</MicrosoftNetCompilersVersion>
     <MicrosoftNetCompilersnetcoreVersion>2.0.0-rc2-61102-09</MicrosoftNetCompilersnetcoreVersion>
-    <MicrosoftNetRoslynDiagnosticsVersion>1.2.0-beta2</MicrosoftNetRoslynDiagnosticsVersion>
+    <MicrosoftNetRoslynDiagnosticsVersion>2.0.0-beta1-61628-06</MicrosoftNetRoslynDiagnosticsVersion>
     <MicrosoftNetCoreILAsmVersion>1.1.0</MicrosoftNetCoreILAsmVersion>
     <MicrosoftNETCoreCompilersVersion>2.3.0-dev-56735-00</MicrosoftNETCoreCompilersVersion>
     <MicrosoftNETCoreVersion>5.0.0</MicrosoftNETCoreVersion>
diff --git a/build/Targets/Settings.props b/build/Targets/Settings.props
index f0933dfe67e3a..84a23b39d3a49 100644
--- a/build/Targets/Settings.props
+++ b/build/Targets/Settings.props
@@ -14,7 +14,7 @@
     <ToolsetPackagesDir>$(RepoRoot)build\ToolsetPackages\</ToolsetPackagesDir>
     <VSIXExpInstallerPackageName>RoslynTools.Microsoft.VSIXExpInstaller</VSIXExpInstallerPackageName>
     <VSIXExpInstallerPackageVersion>0.2.1-beta</VSIXExpInstallerPackageVersion>
-    <RoslynDiagnosticsNugetPackageVersion>2.0.0-beta1-61628-06</RoslynDiagnosticsNugetPackageVersion>
+    <RoslynDiagnosticsNugetPackageVersion>$(MicrosoftNetRoslynDiagnosticsVersion)</RoslynDiagnosticsNugetPackageVersion>
     <RoslynDiagnosticsPropsFilePath>$(NuGetPackageRoot)\Microsoft.Net.RoslynDiagnostics\$(RoslynDiagnosticsNugetPackageVersion)\build\Microsoft.Net.RoslynDiagnostics.props</RoslynDiagnosticsPropsFilePath>
     <RoslynBuildUtilFilePath>$(NuGetPackageRoot)\Roslyn.Build.Util\0.9.4-portable\lib\dotnet\Roslyn.MSBuild.Util.dll</RoslynBuildUtilFilePath>
     <RoslynRuntimeIdentifier Condition="'$(RoslynRuntimeIdentifier)' == '' AND '$(OS)' == 'Windows_NT'">win7-x64</RoslynRuntimeIdentifier>
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index 66f8f5b0dd93c..e4e61df95b69f 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -452,7 +452,7 @@ Microsoft.CodeAnalysis.Semantics.INullCoalescingExpression.PrimaryOperand.get ->
 Microsoft.CodeAnalysis.Semantics.INullCoalescingExpression.SecondaryOperand.get -> Microsoft.CodeAnalysis.IOperation
 Microsoft.CodeAnalysis.Semantics.IObjectCreationExpression
 Microsoft.CodeAnalysis.Semantics.IObjectCreationExpression.Constructor.get -> Microsoft.CodeAnalysis.IMethodSymbol
-Microsoft.CodeAnalysis.Semantics.IObjectCreationExpression.MemberInitializers.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Semantics.ISymbolInitializer>
+Microsoft.CodeAnalysis.Semantics.IObjectCreationExpression.Initializers.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.IOperation>
 Microsoft.CodeAnalysis.Semantics.IOmittedArgumentExpression
 Microsoft.CodeAnalysis.Semantics.IParameterInitializer
 Microsoft.CodeAnalysis.Semantics.IParameterInitializer.Parameter.get -> Microsoft.CodeAnalysis.IParameterSymbol

From 5e053aaf90864362af42d3d7d7b45040e4595fb8 Mon Sep 17 00:00:00 2001
From: Ty Overby <ty@pre-alpha.com>
Date: Wed, 10 May 2017 11:22:55 -0700
Subject: [PATCH 097/284] remove _showPosition (#19353)

---
 .../Portable/Diagnostics/DiagnosticDescription.cs   | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/src/Test/Utilities/Portable/Diagnostics/DiagnosticDescription.cs b/src/Test/Utilities/Portable/Diagnostics/DiagnosticDescription.cs
index 33c8fee399f40..e272088218103 100644
--- a/src/Test/Utilities/Portable/Diagnostics/DiagnosticDescription.cs
+++ b/src/Test/Utilities/Portable/Diagnostics/DiagnosticDescription.cs
@@ -24,7 +24,6 @@ public sealed class DiagnosticDescription
         private readonly string _squiggledText;
         private readonly object[] _arguments;
         private readonly LinePosition? _startPosition; // May not have a value only in the case that we're constructed via factories
-        private bool _showPosition; // show start position in ToString if comparison fails
         private readonly bool _argumentOrderDoesNotMatter;
         private readonly Type _errorCodeType;
         private readonly bool _ignoreArgumentsWhenComparing;
@@ -96,7 +95,7 @@ public DiagnosticDescription(
             _errorCodeType = errorCodeType ?? code.GetType();
         }
 
-        public DiagnosticDescription(Diagnostic d, bool errorCodeOnly, bool showPosition = false)
+        public DiagnosticDescription(Diagnostic d, bool errorCodeOnly)
         {
             _code = d.Code;
             _isWarningAsError = d.IsWarningAsError;
@@ -124,7 +123,6 @@ public DiagnosticDescription(Diagnostic d, bool errorCodeOnly, bool showPosition
             }
 
             _ignoreArgumentsWhenComparing = errorCodeOnly;
-            _showPosition = showPosition;
 
             if (!_ignoreArgumentsWhenComparing)
             {
@@ -219,13 +217,8 @@ public override bool Equals(object obj)
                 {
                     if (_startPosition.Value != d._startPosition.Value)
                     {
-                        _showPosition = true;
-                        d._showPosition = true;
                         return false;
                     }
-
-                    _showPosition = false;
-                    d._showPosition = false;
                 }
             }
 
@@ -354,7 +347,7 @@ public override string ToString()
                 sb.Append(")");
             }
 
-            if (_startPosition != null && _showPosition)
+            if (_startPosition != null)
             {
                 sb.Append(".WithLocation(");
                 sb.Append(_startPosition.Value.Line + 1);
@@ -438,7 +431,7 @@ public static string GetAssertText(DiagnosticDescription[] expected, IEnumerable
                     }
                 }
 
-                var description = new DiagnosticDescription(d, errorCodeOnly: false, showPosition: true);
+                var description = new DiagnosticDescription(d, errorCodeOnly: false);
                 var diffDescription = description;
                 var idx = Array.IndexOf(expected, description);
                 if (idx != -1)

From eddbafc4594b3e00d0e14f0e082e28ea60fe6fce Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Wed, 10 May 2017 12:15:15 -0700
Subject: [PATCH 098/284] Addressed pr feedback, export parts as shared and in
 the correct layer.

---
 Roslyn.sln                                            |  2 +-
 .../Implementation/InfoBar/EditorInfoBarService.cs    | 11 ++++-------
 .../InfoBar/VisualStudioInfoBarService.cs             | 10 +++++-----
 .../VisualStudioErrorReportingServiceFactory.cs       |  1 +
 4 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/Roslyn.sln b/Roslyn.sln
index c865f2080720b..d84b0ca587bd8 100644
--- a/Roslyn.sln
+++ b/Roslyn.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
-VisualStudioVersion = 15.0.26228.4
+VisualStudioVersion = 15.0.26507.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Core", "Core", "{A41D1B99-F489-4C43-BBDF-96D61B19A6B9}"
 EndProject
diff --git a/src/EditorFeatures/Core/Implementation/InfoBar/EditorInfoBarService.cs b/src/EditorFeatures/Core/Implementation/InfoBar/EditorInfoBarService.cs
index bd8a0567fd41b..f4931a206ae92 100644
--- a/src/EditorFeatures/Core/Implementation/InfoBar/EditorInfoBarService.cs
+++ b/src/EditorFeatures/Core/Implementation/InfoBar/EditorInfoBarService.cs
@@ -1,22 +1,19 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System.Composition;
 using Microsoft.CodeAnalysis.Extensions;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Internal.Log;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.Workspaces
 {
-    [ExportWorkspaceService(typeof(IInfoBarService))]
+    [ExportWorkspaceService(typeof(IInfoBarService)), Shared]
     internal class EditorInfoBarService : IInfoBarService
     {
         public void ShowInfoBarInActiveView(string message, params InfoBarUI[] items)
-        {
-            ShowInfoBarInGlobalView(message, items);
-        }
+            => ShowInfoBarInGlobalView(message, items);
 
         public void ShowInfoBarInGlobalView(string message, params InfoBarUI[] items)
-        {
-            Logger.Log(FunctionId.Extension_InfoBar, message);
-        }
+            => Logger.Log(FunctionId.Extension_InfoBar, message);
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/InfoBar/VisualStudioInfoBarService.cs b/src/VisualStudio/Core/Def/Implementation/InfoBar/VisualStudioInfoBarService.cs
index 65c2f2f3d3b0c..905b9f9d2a2bb 100644
--- a/src/VisualStudio/Core/Def/Implementation/InfoBar/VisualStudioInfoBarService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InfoBar/VisualStudioInfoBarService.cs
@@ -2,7 +2,7 @@
 
 using System;
 using System.Collections.Generic;
-using System.ComponentModel.Composition;
+using System.Composition;
 using System.Linq;
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
@@ -16,15 +16,15 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation
 {
-    [ExportWorkspaceService(typeof(IInfoBarService))]
+    [ExportWorkspaceService(typeof(IInfoBarService), layer: ServiceLayer.Host), Shared]
     internal class VisualStudioInfoBarService : ForegroundThreadAffinitizedObject, IInfoBarService
     {
-        private readonly IServiceProvider _serviceProvider;
+        private readonly SVsServiceProvider _serviceProvider;
         private readonly IForegroundNotificationService _foregroundNotificationService;
         private readonly IAsynchronousOperationListener _listener;
 
         [ImportingConstructor]
-        public VisualStudioInfoBarService([Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider,
+        public VisualStudioInfoBarService(SVsServiceProvider serviceProvider,
             IForegroundNotificationService foregroundNotificationService,
             [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners)
         {
@@ -54,7 +54,7 @@ private void ShowInfoBar(bool activeView, string message, params InfoBarUI[] ite
                 {
                     CreateInfoBar(infoBarHost, message, items);
                 }
-            }, _listener.BeginAsyncOperation("Show InfoBar"));
+            }, _listener.BeginAsyncOperation(nameof(ShowInfoBar)));
         }
 
         private bool TryGetInfoBarData(bool activeView, out IVsInfoBarHost infoBarHost)
diff --git a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingServiceFactory.cs b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingServiceFactory.cs
index 4fdc31eaf3991..9a4b54adb60a2 100644
--- a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingServiceFactory.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioErrorReportingServiceFactory.cs
@@ -23,6 +23,7 @@ public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
             {
                 _singleton = new VisualStudioErrorReportingService(workspaceServices.GetRequiredService<IInfoBarService>());
             }
+
             return _singleton;
         }
     }

From b5c01a460a007f284169dab2cc66c5085a2b2f5e Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Tue, 9 May 2017 10:45:29 -0700
Subject: [PATCH 099/284] Added post-suggestion listener

---
 src/EditorFeatures/Core/EditorFeatures.csproj |  1 +
 .../Suggestions/ISuggestedActionCallback.cs   | 13 ++++++
 .../SuggestedActions/SuggestedAction.cs       | 10 +++--
 .../SuggestedActionsSourceProvider.cs         |  5 ++-
 .../AnalyzerVsixSuggestedActionCallback.cs    | 45 +++++++++++++++++++
 .../Core/Def/ServicesVSResources.Designer.cs  | 20 ++++++++-
 .../Core/Def/ServicesVSResources.resx         | 10 ++++-
 .../Core/Def/ServicesVisualStudio.csproj      |  2 +
 8 files changed, 99 insertions(+), 7 deletions(-)
 create mode 100644 src/EditorFeatures/Core/Implementation/Suggestions/ISuggestedActionCallback.cs
 create mode 100644 src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs

diff --git a/src/EditorFeatures/Core/EditorFeatures.csproj b/src/EditorFeatures/Core/EditorFeatures.csproj
index c4ca714ba6082..ebf13ede91907 100644
--- a/src/EditorFeatures/Core/EditorFeatures.csproj
+++ b/src/EditorFeatures/Core/EditorFeatures.csproj
@@ -166,6 +166,7 @@
     <Compile Include="Implementation\Intellisense\Completion\CompletionFilterReason.cs" />
     <Compile Include="Implementation\Intellisense\Completion\FilterResult.cs" />
     <Compile Include="Implementation\Structure\BlockTagState.cs" />
+    <Compile Include="Implementation\Suggestions\ISuggestedActionCallback.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionSetComparer.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionsSource.cs" />
     <Compile Include="Implementation\InfoBar\EditorInfoBarService.cs" />
diff --git a/src/EditorFeatures/Core/Implementation/Suggestions/ISuggestedActionCallback.cs b/src/EditorFeatures/Core/Implementation/Suggestions/ISuggestedActionCallback.cs
new file mode 100644
index 0000000000000..9c8ab22467d9d
--- /dev/null
+++ b/src/EditorFeatures/Core/Implementation/Suggestions/ISuggestedActionCallback.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.Suggestions
+{
+    internal interface ISuggestedActionCallback
+    {
+        void OnSuggestedActionExecuted(SuggestedAction action);
+    }
+}
diff --git a/src/EditorFeatures/Core/Implementation/Suggestions/SuggestedActions/SuggestedAction.cs b/src/EditorFeatures/Core/Implementation/Suggestions/SuggestedActions/SuggestedAction.cs
index 07b363341747d..b2b75345f4a4e 100644
--- a/src/EditorFeatures/Core/Implementation/Suggestions/SuggestedActions/SuggestedAction.cs
+++ b/src/EditorFeatures/Core/Implementation/Suggestions/SuggestedActions/SuggestedAction.cs
@@ -90,21 +90,25 @@ protected Task<ImmutableArray<CodeActionOperation>> GetPreviewOperationsAsync(Ca
 
         public void Invoke(CancellationToken cancellationToken)
         {
-            // While we're not technically doing anything async here, we need to let the 
+            // While we're not technically doing anything async here, we need to let the
             // integration test harness know that it should not proceed until all this
             // work is done.  Otherwise it might ask to do some work before we finish.
             // That can happen because although we're on the UI thread, we may do things
             // that end up causing VS to pump the messages that the test harness enqueues
-            // to the UI thread as well.  
+            // to the UI thread as well.
             using (SourceProvider.OperationListener.BeginAsyncOperation($"{nameof(SuggestedAction)}.{nameof(Invoke)}"))
             {
-                // WaitIndicator cannot be used with async/await. Even though we call async methods 
+                // WaitIndicator cannot be used with async/await. Even though we call async methods
                 // later in this call chain, do not await them.
                 SourceProvider.WaitIndicator.Wait(CodeAction.Title, CodeAction.Message, allowCancel: true, showProgress: true, action: waitContext =>
                 {
                     using (var linkedSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, waitContext.CancellationToken))
                     {
                         InnerInvoke(waitContext.ProgressTracker, linkedSource.Token);
+                        foreach (var actionCallback in SourceProvider.ActionCallbacks)
+                        {
+                            actionCallback.Value.OnSuggestedActionExecuted(this);
+                        }
                     }
                 });
             }
diff --git a/src/EditorFeatures/Core/Implementation/Suggestions/SuggestedActionsSourceProvider.cs b/src/EditorFeatures/Core/Implementation/Suggestions/SuggestedActionsSourceProvider.cs
index 357f649bb1576..41559e3c9cf1d 100644
--- a/src/EditorFeatures/Core/Implementation/Suggestions/SuggestedActionsSourceProvider.cs
+++ b/src/EditorFeatures/Core/Implementation/Suggestions/SuggestedActionsSourceProvider.cs
@@ -39,6 +39,7 @@ internal partial class SuggestedActionsSourceProvider : ISuggestedActionsSourceP
         public readonly ICodeActionEditHandlerService EditHandler;
         public readonly IAsynchronousOperationListener OperationListener;
         public readonly IWaitIndicator WaitIndicator;
+        public readonly ImmutableArray<Lazy<ISuggestedActionCallback>> ActionCallbacks;
 
         public readonly ImmutableArray<Lazy<IImageMonikerService, OrderableMetadata>> ImageMonikerServices;
 
@@ -50,11 +51,13 @@ public SuggestedActionsSourceProvider(
             ICodeActionEditHandlerService editHandler,
             IWaitIndicator waitIndicator,
             [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners,
-            [ImportMany] IEnumerable<Lazy<IImageMonikerService, OrderableMetadata>> imageMonikerServices)
+            [ImportMany] IEnumerable<Lazy<IImageMonikerService, OrderableMetadata>> imageMonikerServices,
+            [ImportMany] IEnumerable<Lazy<ISuggestedActionCallback>> actionCallbacks)
         {
             _codeRefactoringService = codeRefactoringService;
             _diagnosticService = diagnosticService;
             _codeFixService = codeFixService;
+            ActionCallbacks = actionCallbacks.ToImmutableArray();
             EditHandler = editHandler;
             WaitIndicator = waitIndicator;
             OperationListener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.LightBulb);
diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
new file mode 100644
index 0000000000000..25430d51d5538
--- /dev/null
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.ComponentModel.Composition;
+using Microsoft.CodeAnalysis.Editor.Implementation.Suggestions;
+using Microsoft.CodeAnalysis.Experiments;
+using Microsoft.CodeAnalysis.Extensions;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.Experimentation
+{
+    [Export(typeof(ISuggestedActionCallback))]
+    class AnalyzerVsixSuggestedActionCallback : ISuggestedActionCallback
+    {
+        private const string AnalyzerEnabledFlight = @"LiveCA/LiveCAcf";
+        private const string AnalyzerVsixHyperlink = @"https://aka.ms/livecodeanalysis";
+
+        private readonly VisualStudioWorkspace _workspace;
+        private readonly IInfoBarService _infoBarService;
+
+        [ImportingConstructor]
+        public AnalyzerVsixSuggestedActionCallback(IInfoBarService infoBarService, VisualStudioWorkspace workspace)
+        {
+            _workspace = workspace;
+            _infoBarService = infoBarService;
+        }
+
+        public void OnSuggestedActionExecuted(SuggestedAction action)
+        {
+            var experimentationService = _workspace.Services.GetRequiredService<IExperimentationService>();
+            if (experimentationService.IsExperimentEnabled(AnalyzerEnabledFlight))
+            {
+                _infoBarService.ShowInfoBarInGlobalView(
+                    ServicesVSResources.Analyzer_vsix_try_description,
+                    new InfoBarUI(title: ServicesVSResources.Analyzer_vsix_hyperlink,
+                                  kind: InfoBarUI.UIKind.HyperLink,
+                                  action: new Action(OpenInstallHyperlink)));
+            }
+        }
+
+        private void OpenInstallHyperlink()
+        {
+            System.Diagnostics.Process.Start(AnalyzerVsixHyperlink);
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs b/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
index f151708ab124c..09fb93e50562c 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
@@ -19,7 +19,7 @@ namespace Microsoft.VisualStudio.LanguageServices {
     // class via a tool like ResGen or Visual Studio.
     // To add or remove a member, edit your .ResX file then rerun ResGen
     // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
     internal class ServicesVSResources {
@@ -226,6 +226,24 @@ internal static string Analyzer_reference_to_0_in_project_1 {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Install.
+        /// </summary>
+        internal static string Analyzer_vsix_hyperlink {
+            get {
+                return ResourceManager.GetString("Analyzer_vsix_hyperlink", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Try the new analyzer extension!.
+        /// </summary>
+        internal static string Analyzer_vsix_try_description {
+            get {
+                return ResourceManager.GetString("Analyzer_vsix_try_description", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to AnalyzerChangedOnDisk.
         /// </summary>
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index e23b643793526..b1042e7f920e0 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -906,10 +906,16 @@ Additional information: {1}</value>
   <data name="prefer_throwing_properties" xml:space="preserve">
     <value>prefer throwing properties</value>
   </data>
-    <data name="When_generating_properties" xml:space="preserve">
+  <data name="When_generating_properties" xml:space="preserve">
     <value>When generating properties:</value>
-    </data>
+  </data>
   <data name="Options" xml:space="preserve">
     <value>Options</value>
   </data>
+  <data name="Analyzer_vsix_hyperlink" xml:space="preserve">
+    <value>Install</value>
+  </data>
+  <data name="Analyzer_vsix_try_description" xml:space="preserve">
+    <value>Try the new analyzer extension!</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj b/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
index 4c7b48649bd96..ac3b8ac9c1909 100644
--- a/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
+++ b/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
@@ -62,6 +62,7 @@
     <Compile Include="Implementation\EditAndContinue\Interop\NativeMethods.cs" />
     <Compile Include="Implementation\AnalyzerDependency\IIgnorableAssemblyList.cs" />
     <Compile Include="Implementation\AnalyzerDependency\IBindingRedirectionService.cs" />
+    <Compile Include="Implementation\Experimentation\AnalyzerVsixSuggestedActionCallback.cs" />
     <Compile Include="Implementation\Extensions\ServiceProviderExtensions.cs" />
     <Compile Include="ID.InteractiveCommands.cs" />
     <Compile Include="Implementation\FindReferences\VisualStudioDefinitionsAndReferencesFactory.cs" />
@@ -801,6 +802,7 @@
       <SubType>Designer</SubType>
     </VSCTCompile>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="..\..\..\Dependencies\CodeAnalysis.Metadata\Microsoft.CodeAnalysis.Metadata.projitems" Label="Shared" />
   <Import Project="..\..\..\..\build\Targets\Imports.targets" />
 </Project>
\ No newline at end of file

From a4dbea3760cc7b3f3093957312077876a59959d8 Mon Sep 17 00:00:00 2001
From: Tom Meschter <tom.meschter@microsoft.com>
Date: Wed, 10 May 2017 12:29:24 -0700
Subject: [PATCH 100/284] Use file path to hook up analyzers nodes in Solution
 Explorer

Fixes https://github.com/dotnet/project-system/issues/2062.

Currently we match a hierarchy node representing an analyzer in Solution Explorer up to the proper Roslyn `AnalyzerReference` based on the "display name"--basically, the name of the assembly without the extension. This mostly works, but you can run into problems if a project uses two different versions of the same analyzer, each with a different set of diagnostics. In this case expanding one of the analyzer nodes in Solution Explorer will show you the wrong set of diagnostics for one or the other, since they both have the same display name.

To uniquely identify an analyzer assembly we should use its full path rather than the display name. However, the project system initially didn't expose the full path through the hierarchy node. This has been fixed, and now the full path is one of the components of the node's "canonical name", along with other bits of information such as the project directory and target framework.

This commit updates our code to extract and use the full path instead of the display name.
---
 .../CpsDiagnosticItemProvider.cs              |  8 ++-
 .../DiagnosticItem/CpsDiagnosticItemSource.cs | 51 +++++++++++++++++--
 2 files changed, 53 insertions(+), 6 deletions(-)

diff --git a/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsDiagnosticItemProvider.cs b/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsDiagnosticItemProvider.cs
index c645392f6df45..ce905c3315d24 100644
--- a/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsDiagnosticItemProvider.cs
+++ b/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsDiagnosticItemProvider.cs
@@ -121,7 +121,13 @@ private IAttachedCollectionSource CreateCollectionSourceCore(IVsHierarchyItem pr
             {
                 var workspace = TryGetWorkspace();
                 var analyzerService = GetAnalyzerService();
-                return new CpsDiagnosticItemSource(workspace, projectId, item, _commandHandler, analyzerService);
+
+                var hierarchy = projectRootItem.HierarchyIdentity.NestedHierarchy;
+                var itemId = projectRootItem.HierarchyIdentity.NestedItemID;
+                if (hierarchy.GetCanonicalName(itemId, out string projectCanonicalName) == VSConstants.S_OK)
+                {
+                    return new CpsDiagnosticItemSource(workspace, projectCanonicalName, projectId, item, _commandHandler, analyzerService);
+                }
             }
 
             return null;
diff --git a/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsDiagnosticItemSource.cs b/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsDiagnosticItemSource.cs
index 81713c046cdb1..af77b64267226 100644
--- a/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsDiagnosticItemSource.cs
+++ b/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsDiagnosticItemSource.cs
@@ -1,11 +1,12 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.ComponentModel;
+using System.IO;
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.Internal.VisualStudio.PlatformUI;
-using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
 using Microsoft.VisualStudio.Shell;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.SolutionExplorer
@@ -13,15 +14,17 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.SolutionExplore
     internal partial class CpsDiagnosticItemSource : BaseDiagnosticItemSource, INotifyPropertyChanged
     {
         private readonly IVsHierarchyItem _item;
+        private readonly string _projectDirectoryPath;
 
         private AnalyzerReference _analyzerReference;
 
         public event PropertyChangedEventHandler PropertyChanged;
 
-        public CpsDiagnosticItemSource(Workspace workspace, ProjectId projectId, IVsHierarchyItem item, IAnalyzersCommandHandler commandHandler, IDiagnosticAnalyzerService analyzerService)
+        public CpsDiagnosticItemSource(Workspace workspace, string projectPath, ProjectId projectId, IVsHierarchyItem item, IAnalyzersCommandHandler commandHandler, IDiagnosticAnalyzerService analyzerService)
             : base(workspace, projectId, commandHandler, analyzerService)
         {
             _item = item;
+            _projectDirectoryPath = Path.GetDirectoryName(projectPath);
 
             _analyzerReference = TryGetAnalyzerReference(_workspace.CurrentSolution);
             if (_analyzerReference == null)
@@ -91,12 +94,50 @@ private AnalyzerReference TryGetAnalyzerReference(Solution solution)
                 return null;
             }
 
-            if (!_item.HierarchyIdentity.NestedHierarchy.TryGetItemName(_item.HierarchyIdentity.NestedItemID, out string name))
+            var canonicalName = _item.CanonicalName;
+            var analyzerFilePath = ExtractAnalyzerFilePath(canonicalName);
+
+            return project.AnalyzerReferences.FirstOrDefault(r => r.FullPath.Equals(analyzerFilePath, StringComparison.OrdinalIgnoreCase));
+        }
+
+        /// <summary>
+        /// Given the canonical name of a node representing an analyzer assembly in the
+        /// CPS-based project system extracts out the full path to the assembly.
+        /// </summary>
+        /// <remarks>
+        /// The canonical name takes the following form:
+        /// 
+        ///   [{path to project directory}\]{target framework}\analyzerdependency\{path to assembly}
+        ///   
+        /// e.g.:
+        /// 
+        ///   C:\projects\solutions\MyProj\netstandard2.0\analyzerdependency\C:\users\me\.packages\somePackage\lib\someAnalyzer.dll
+        ///   
+        /// This method exists solely to extract out the "path to assembly" part, i.e.
+        /// "C:\users\me\.packages\somePackage\lib\someAnalyzer.dll". We don't need the
+        /// other parts.
+        /// 
+        /// Note that the path to the project directory is optional. It's not clear if
+        /// this is intentional or a bug in the project system, but either way it
+        /// doesn't really matter.
+        /// </remarks>
+        private string ExtractAnalyzerFilePath(string canonicalName)
+        {
+            // The canonical name may or may not start with the path to the project's directory.
+            if (canonicalName.StartsWith(_projectDirectoryPath, StringComparison.OrdinalIgnoreCase))
             {
-                return null;
+                // Extract the rest of the string, taking into account the "\" separating the directory
+                // path from the rest of the canonical name
+                canonicalName = canonicalName.Substring(_projectDirectoryPath.Length + 1);
             }
 
-            return project.AnalyzerReferences.FirstOrDefault(r => r.Display.Equals(name));
+            // Find the slash after the target framework
+            var backslashIndex = canonicalName.IndexOf('\\');
+            // Find the slash after "analyzerdependency"
+            backslashIndex = canonicalName.IndexOf('\\', backslashIndex + 1);
+
+            // The rest of the string is the path.
+            return canonicalName.Substring(backslashIndex + 1);
         }
     }
 }
\ No newline at end of file

From 4a1b805ff47f6e25cd9ebb3cb4c81d35c25f36ce Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 12:30:40 -0700
Subject: [PATCH 101/284] Simplify check.

---
 ...actUseThrowExpressionDiagnosticAnalyzer.cs | 27 ++++++-------------
 1 file changed, 8 insertions(+), 19 deletions(-)

diff --git a/src/Features/Core/Portable/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs b/src/Features/Core/Portable/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
index a0c92f5d6c605..e405a6e5757c0 100644
--- a/src/Features/Core/Portable/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/Core/Portable/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
@@ -116,12 +116,6 @@ private void AnalyzeOperation(OperationAnalysisContext context, INamedTypeSymbol
                 return;
             }
 
-            if (!IsOnlyStatementOfIf(ifOperation, throwOperation))
-            {
-                // The if-statement can only have a single throw-statement in it.
-                return;
-            }
-
             var containingBlock = GetOperation(
                 semanticModel, ifOperation.Syntax.Parent, cancellationToken) as IBlockStatement;
             if (containingBlock == null)
@@ -195,18 +189,6 @@ private void AnalyzeOperation(OperationAnalysisContext context, INamedTypeSymbol
             }
         }
 
-        private bool IsOnlyStatementOfIf(IIfStatement ifOperation, IThrowStatement throwStatement)
-        {
-            if (ifOperation.IfTrueStatement.Syntax == throwStatement.Syntax)
-            {
-                return true;
-            }
-
-            return ifOperation.IfTrueStatement is IBlockStatement block &&
-                   block.Statements.Length == 1 &&
-                   block.Statements[0].Syntax == throwStatement.Syntax;
-        }
-
         protected abstract ISyntaxFactsService GetSyntaxFactsService();
         protected abstract ISemanticFactsService GetSemanticFactsService();
 
@@ -318,8 +300,15 @@ private IIfStatement GetContainingIfOperation(
             var containingOperation = GetOperation(
                 semanticModel, throwStatement.Parent, cancellationToken);
 
-            if (containingOperation?.Kind == OperationKind.BlockStatement)
+            if (containingOperation is IBlockStatement block)
             {
+                if (block.Statements.Length != 1)
+                {
+                    // If we are in a block, then the block must only contain
+                    // the throw statement.
+                    return null;
+                }
+
                 // C# may have an intermediary block between the throw-statement
                 // and the if-statement.  Walk up one operation higher in that case.
                 containingOperation = GetOperation(

From 7c5039453c6af7dd78d47fb372da402a083f73bb Mon Sep 17 00:00:00 2001
From: Ivan Basov <basov@hotmail.com>
Date: Wed, 10 May 2017 13:43:49 -0700
Subject: [PATCH 102/284] Migrate BasicEditAndContinue integration tests from
 Tao to .NET (#19381)

Tests only. No ask mode approval is required.
---
 .../VisualBasic/BasicEditAndContinue.cs       | 326 ++++++++++++++++++
 .../VisualStudioIntegrationTests.csproj       |   1 +
 .../TestUtilities/Common/Expression.cs        |  23 ++
 .../InProcess/Debugger_InProc.cs              |  37 ++
 .../TestUtilities/InProcess/Editor_InProc.cs  |  39 +++
 .../InProcess/LocalsWindow_InProc.cs          |  30 ++
 .../InProcess/VisualStudio_InProc.cs          |   4 +-
 .../TestUtilities/IntegrationHelper.cs        |  10 +-
 .../OutOfProcess/Debugger_OutOfProc.cs        |  51 +++
 .../OutOfProcess/Dialog_OutOfProc.cs          |  30 ++
 .../OutOfProcess/Editor_OutOfProc.Verifier.cs |   5 +
 .../OutOfProcess/Editor_OutOfProc.cs          |  10 +
 .../ErrorList_OutOfProc.Verifier.cs           |   5 +
 .../LocalsWindow_OutOfProc.Verifier.cs        |  26 ++
 .../OutOfProcess/LocalsWindow_OutOfProc.cs    |  19 +
 .../TestUtilities/VisualStudioInstance.cs     |  13 +-
 ...isualStudioIntegrationTestUtilities.csproj |   7 +
 17 files changed, 629 insertions(+), 7 deletions(-)
 create mode 100644 src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
 create mode 100644 src/VisualStudio/IntegrationTest/TestUtilities/Common/Expression.cs
 create mode 100644 src/VisualStudio/IntegrationTest/TestUtilities/InProcess/Debugger_InProc.cs
 create mode 100644 src/VisualStudio/IntegrationTest/TestUtilities/InProcess/LocalsWindow_InProc.cs
 create mode 100644 src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Debugger_OutOfProc.cs
 create mode 100644 src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Dialog_OutOfProc.cs
 create mode 100644 src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/LocalsWindow_OutOfProc.Verifier.cs
 create mode 100644 src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/LocalsWindow_OutOfProc.cs

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
new file mode 100644
index 0000000000000..7643daa7d20bd
--- /dev/null
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
@@ -0,0 +1,326 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.VisualStudio.IntegrationTest.Utilities;
+using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
+using Xunit;
+using ProjectUtils = Microsoft.VisualStudio.IntegrationTest.Utilities.Common.ProjectUtils;
+
+namespace Roslyn.VisualStudio.IntegrationTests.VisualBasic
+{
+    [Collection(nameof(SharedIntegrationHostFixture))]
+    public class BasicEditAndContinue : AbstractEditorTest
+    {
+        private const string module1FileName = "Module1.vb";
+
+        public BasicEditAndContinue(VisualStudioInstanceFactory instanceFactory) : base(instanceFactory)
+        {
+            VisualStudio.SolutionExplorer.CreateSolution(nameof(BasicBuild));
+            var testProj = new ProjectUtils.Project("TestProj");
+            VisualStudio.SolutionExplorer.AddProject(testProj, WellKnownProjectTemplates.ConsoleApplication, LanguageNames.VisualBasic);
+        }
+
+        protected override string LanguageName => LanguageNames.VisualBasic;
+
+        [Fact]
+        public void UpdateActiveStatementLeafNode()
+        {
+            VisualStudio.Editor.SetText(@"
+Imports System
+Imports System.Collections.Generic
+Imports System.Linq
+
+Module Module1
+    Sub Main()
+        Dim names(2) As String
+        names(0) = ""foo""
+        names(1) = ""bar""
+
+        For index = 0 To names.GetUpperBound(0)
+            Console.WriteLine(names(index))
+        Next
+    End Sub
+End Module
+");
+
+            VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
+            VisualStudio.Debugger.SetBreakPoint(module1FileName, "names(0)");
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+            VisualStudio.Editor.ReplaceText("names(0)", "names(1)");
+            VisualStudio.Debugger.StepOver(waitForBreakOrEnd: true);
+            VisualStudio.Debugger.CheckExpression("names(1)", "String", "\"foo\"");
+            VisualStudio.Debugger.StepOver(waitForBreakOrEnd: true);
+            VisualStudio.Debugger.CheckExpression("names(1)", "String", "\"bar\"");
+        }
+
+        [Fact]
+        public void AddTryCatchAroundActiveStatement()
+        {
+            VisualStudio.Editor.SetText(@"
+Imports System
+Module Module1
+    Sub Main()
+        Foo()
+    End Sub
+
+    Private Sub Foo()
+        Console.WriteLine(1)
+    End Sub
+End Module");
+
+            VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
+            VisualStudio.Debugger.SetBreakPoint(module1FileName, "Console.WriteLine(1)");
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+            VisualStudio.Editor.ReplaceText("Console.WriteLine(1)",
+                @"Try
+Console.WriteLine(1)
+Catch ex As Exception
+End Try");
+            VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
+            VisualStudio.Debugger.StepOver(waitForBreakOrEnd: true);
+            VisualStudio.Editor.Verify.CurrentLineText("End Try");
+        }
+
+        [Fact]
+        public void EditLambdaExpression()
+        {
+            VisualStudio.Editor.SetText(@"
+Imports System
+Module Module1
+    Private Delegate Function del(i As Integer) As Integer
+
+    Sub Main()
+        Dim myDel As del = Function(x) x * x
+        Dim j As Integer = myDel(5)
+    End Sub
+End Module");
+
+            VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
+            VisualStudio.Debugger.SetBreakPoint(module1FileName, "x * x", charsOffset: -1);
+
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+            VisualStudio.Editor.ReplaceText("x * x", "x * 2");
+
+            VisualStudio.Debugger.StepOver(waitForBreakOrEnd: false);
+            VisualStudio.Debugger.Stop(waitForDesignMode: true);
+            VisualStudio.ErrorList.Verify.NoBuildErrors();
+
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+            VisualStudio.Editor.ReplaceText("x * 2", "x * x");
+            VisualStudio.Debugger.StepOver(waitForBreakOrEnd: true);
+            VisualStudio.Debugger.Stop(waitForDesignMode: true);
+            VisualStudio.ErrorList.Verify.NoBuildErrors();
+        }
+
+        [Fact]
+        public void EnCWhileDebuggingFromImmediateWindow()
+        {
+            VisualStudio.Editor.SetText(@"
+Imports System
+
+Module Module1
+    Sub Main()
+        Dim x = 4
+        Console.WriteLine(x)
+    End Sub
+End Module");
+
+            VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+            VisualStudio.Debugger.SetBreakPoint(module1FileName, "Dim x", charsOffset: 1);
+            VisualStudio.Debugger.ExecuteStatement("Module1.Main()");
+            VisualStudio.Editor.ReplaceText("x = 4", "x = 42");
+            VisualStudio.Debugger.StepOver(waitForBreakOrEnd: true);
+            VisualStudio.Debugger.CheckExpression("x", "Integer", "42");
+            VisualStudio.Debugger.ExecuteStatement("Module1.Main()");
+        }
+
+        private void SetupMultiProjectSolution()
+        {
+            var basicLibrary = new ProjectUtils.Project("BasicLibrary1");
+            VisualStudio.SolutionExplorer.AddProject(basicLibrary, WellKnownProjectTemplates.ClassLibrary, LanguageNames.VisualBasic);
+
+            var cSharpLibrary = new ProjectUtils.Project("CSharpLibrary1");
+            VisualStudio.SolutionExplorer.AddProject(cSharpLibrary, WellKnownProjectTemplates.ClassLibrary, LanguageNames.CSharp);
+            VisualStudio.SolutionExplorer.AddFile(cSharpLibrary, "File1.cs");
+
+            VisualStudio.SolutionExplorer.OpenFile(basicLibrary, "Class1.vb");
+            VisualStudio.Editor.SetText(@"
+Imports System
+Public Class Class1
+    Public Sub New()
+    End Sub
+
+    Public Sub PrintX(x As Integer)
+        Console.WriteLine(x)
+    End Sub
+End Class
+");
+
+            var project = new ProjectUtils.Project(ProjectName);
+            VisualStudio.SolutionExplorer.AddProjectReference(project, new ProjectUtils.ProjectReference("BasicLibrary1"));
+            VisualStudio.SolutionExplorer.OpenFile(project, module1FileName);
+
+            VisualStudio.Editor.SetText(@"
+Imports System
+Imports BasicLibrary1
+
+Module Module1
+    Sub Main()
+        Dim c As New Class1()
+        c.PrintX(5)
+    End Sub
+End Module
+");
+
+            VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
+        }
+
+        [Fact]
+        public void MultiProjectDebuggingWhereNotAllModulesAreLoaded()
+        {
+            SetupMultiProjectSolution();
+            VisualStudio.Debugger.SetBreakPoint(module1FileName, "PrintX", charsOffset: 1);
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+            VisualStudio.Editor.ReplaceText("5", "42");
+            VisualStudio.Debugger.StepOver(waitForBreakOrEnd: false);
+            VisualStudio.ErrorList.Verify.NoErrors();
+        }
+
+        [Fact]
+        public void DocumentStateTrackingReadonlyInRunMode()
+        {
+            SetupMultiProjectSolution();
+            var project = new ProjectUtils.Project(ProjectName);
+            var basicLibrary = new ProjectUtils.Project("BasicLibrary1");
+            var cSharpLibrary = new ProjectUtils.Project("CSharpLibrary1");
+
+            VisualStudio.Editor.SetText(@"
+Imports System
+Imports BasicLibrary1
+Module Module1
+    Sub Main()
+        Console.Read()
+    End Sub
+End Module
+");
+            VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
+            VisualStudio.Debugger.Go(waitForBreakMode: false);
+            VisualStudio.ActivateMainWindow(skipAttachingThreads: true);
+            VisualStudio.SolutionExplorer.OpenFile(project, module1FileName);
+
+            VisualStudio.SendKeys.Send(VirtualKey.T);
+            string editAndContinueDialogName = "Edit and Continue";
+            VisualStudio.Dialog.VerifyOpen(editAndContinueDialogName);
+            VisualStudio.Dialog.Click(editAndContinueDialogName, "OK");
+            VisualStudio.Dialog.VerifyClosed(editAndContinueDialogName);
+            VisualStudio.Editor.Verify.IsProjectItemDirty(expectedValue: false);
+
+            // This module is referred by the loaded module, but not used. So this will not be loaded
+            VisualStudio.SolutionExplorer.OpenFile(basicLibrary, "Class1.vb");
+            VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
+            VisualStudio.SendKeys.Send(VirtualKey.T);
+            VisualStudio.Dialog.VerifyOpen(editAndContinueDialogName);
+            VisualStudio.Dialog.Click(editAndContinueDialogName, "OK");
+            VisualStudio.Dialog.VerifyClosed(editAndContinueDialogName);
+            VisualStudio.Editor.Verify.IsProjectItemDirty(expectedValue: false);
+
+            //  This module is not referred by the loaded module. this will not be loaded
+            VisualStudio.SolutionExplorer.OpenFile(cSharpLibrary, "File1.cs");
+            VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
+            VisualStudio.SendKeys.Send(VirtualKey.T);
+
+            string microsoftVisualStudionDialogName = "Microsoft Visual Studio";
+            VisualStudio.Dialog.VerifyOpen(microsoftVisualStudionDialogName);
+            VisualStudio.Dialog.Click(microsoftVisualStudionDialogName, "OK");
+            VisualStudio.Dialog.VerifyClosed(microsoftVisualStudionDialogName);
+            VisualStudio.Editor.Verify.IsProjectItemDirty(expectedValue: false);
+        }
+
+        [Fact]
+        public void LocalsWindowUpdatesAfterLocalGetsItsTypeUpdatedDuringEnC()
+        {
+            VisualStudio.Editor.SetText(@"
+Imports System
+Module Module1
+    Sub Main()
+        Dim foo As String = ""abc""
+        Console.WriteLine(foo)
+    End Sub
+End Module
+");
+            VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
+            VisualStudio.Debugger.SetBreakPoint(module1FileName, "End Sub");
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+            VisualStudio.Editor.ReplaceText("Dim foo As String = \"abc\"", "Dim foo As Single = 10");
+            VisualStudio.Editor.SelectTextInCurrentDocument("Sub Main()");
+            VisualStudio.Debugger.SetNextStatement();
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+
+            VisualStudio.LocalsWindow.Verify.CheckEntry("foo", "Single", "10");
+        }
+
+        [Fact]
+        public void LocalsWindowUpdatesCorrectlyDuringEnC()
+        {
+            VisualStudio.Editor.SetText(@"
+Imports System
+
+Module Module1
+    Sub Main()
+        bar(5)
+    End Sub
+
+    Function bar(ByVal moo As Long) As Decimal
+        Dim iInt As Integer = 0
+        Dim lLng As Long = 5
+        
+        iInt += 30
+        Return 4
+    End Function
+End Module
+");
+            VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
+            VisualStudio.Debugger.SetBreakPoint(module1FileName, "Function bar(ByVal moo As Long) As Decimal");
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+            VisualStudio.Editor.ReplaceText("Dim lLng As Long = 5", "Dim lLng As Long = 444");
+            VisualStudio.Debugger.SetBreakPoint(module1FileName, "Return 4");
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+
+            VisualStudio.LocalsWindow.Verify.CheckEntry("bar", "Decimal", "0");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("moo", "Long", "5");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("iInt", "Integer", "30");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("lLng", "Long", "444");
+        }
+
+        [Fact]
+        public void WatchWindowUpdatesCorrectlyDuringEnC()
+        {
+            VisualStudio.Editor.SetText(@"
+Imports System
+
+Module Module1
+    Sub Main()
+        Dim iInt As Integer = 0
+        System.Diagnostics.Debugger.Break()
+    End Sub
+End Module
+");
+
+            VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+
+            VisualStudio.Debugger.CheckExpression("iInt", "Integer", "0");
+
+            VisualStudio.Editor.ReplaceText("System.Diagnostics.Debugger.Break()", @"iInt = 5
+System.Diagnostics.Debugger.Break()");
+
+            VisualStudio.Editor.SelectTextInCurrentDocument("iInt = 5");
+            VisualStudio.Debugger.SetNextStatement();
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+
+            VisualStudio.Debugger.CheckExpression("iInt", "Integer", "5");
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualStudioIntegrationTests.csproj b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualStudioIntegrationTests.csproj
index 94fe76840afc8..0529e228bc986 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualStudioIntegrationTests.csproj
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualStudioIntegrationTests.csproj
@@ -64,6 +64,7 @@
     <Compile Include="CSharp\CSharpSquigglesNetCore.cs" />
     <Compile Include="CSharp\CSharpWinForms.cs" />
     <Compile Include="CSharp\CSharpAddMissingReference.cs" />
+    <Compile Include="VisualBasic\BasicEditAndContinue.cs" />
     <Compile Include="VisualBasic\BasicEndConstruct.cs" />
     <Compile Include="VisualBasic\BasicReferenceHighlighting.cs" />
     <Compile Include="VisualBasic\BasicKeywordHighlighting.cs" />
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/Common/Expression.cs b/src/VisualStudio/IntegrationTest/TestUtilities/Common/Expression.cs
new file mode 100644
index 0000000000000..30e6235a3872a
--- /dev/null
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/Common/Expression.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.VisualStudio.IntegrationTest.Utilities.Common
+{
+    [Serializable]
+    public class Expression
+    {
+        public string Name { get; set; }
+
+        public string Type { get; set; }
+
+        public string Value { get; set; }
+
+        public Expression(EnvDTE.Expression input)
+        {
+            Name = input.Name;
+            Type = input.Type;
+            Value = input.Value;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/Debugger_InProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/Debugger_InProc.cs
new file mode 100644
index 0000000000000..ccbda1f1747a1
--- /dev/null
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/Debugger_InProc.cs
@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using EnvDTE;
+
+namespace Microsoft.VisualStudio.IntegrationTest.Utilities.InProcess
+{
+    internal class Debugger_InProc : InProcComponent
+    {
+        private readonly Debugger _debugger;
+
+        private Debugger_InProc()
+        {
+            _debugger = GetDTE().Debugger;
+        }
+
+        public static Debugger_InProc Create()
+            => new Debugger_InProc();
+
+        public void SetBreakPoint(string fileName, int lineNumber, int columnIndex)
+        {
+            // Need to increment the line number because editor line numbers starts from 0 but the debugger ones starts from 1.
+            _debugger.Breakpoints.Add(File: fileName, Line: lineNumber + 1, Column: columnIndex);
+        }
+
+        public void Go(bool waitForBreakMode) => _debugger.Go(waitForBreakMode);
+
+        public void StepOver(bool waitForBreakOrEnd) => _debugger.StepOver(waitForBreakOrEnd);
+
+        public void Stop(bool waitForDesignMode) => _debugger.Stop(WaitForDesignMode: waitForDesignMode);
+
+        public void SetNextStatement() => _debugger.SetNextStatement();
+
+        public void ExecuteStatement(string statement) => _debugger.ExecuteStatement(statement);
+
+        public Common.Expression GetExpression(string expressionText) => new Common.Expression(_debugger.GetExpression(expressionText));
+    }
+}
\ No newline at end of file
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/Editor_InProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/Editor_InProc.cs
index a9337b07b26ba..8b57ac5cd43fd 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/Editor_InProc.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/Editor_InProc.cs
@@ -78,6 +78,9 @@ public void WaitForActiveView(string expectedView)
         public void Activate()
             => GetDTE().ActiveDocument.Activate();
 
+        public bool IsProjectItemDirty()
+            => GetDTE().ActiveDocument.ProjectItem.IsDirty;
+
         public string GetText()
             => ExecuteOnActiveView(view => view.TextSnapshot.GetText());
 
@@ -89,6 +92,21 @@ public void SetText(string text)
                 view.TextBuffer.Replace(replacementSpan, text);
             });
 
+        public void SelectText(string text)
+        {
+            PlaceCaret(text, charsOffset: -1, occurrence: 0, extendSelection: false, selectBlock: false);
+            PlaceCaret(text, charsOffset: 0, occurrence: 0, extendSelection: true, selectBlock: false);
+        }
+
+        public void ReplaceText(string oldText, string newText)
+            => ExecuteOnActiveView(view =>
+            {
+                var textSnapshot = view.TextSnapshot;
+                SelectText(oldText);                
+                var replacementSpan = new SnapshotSpan(textSnapshot, view.Selection.Start.Position, view.Selection.End.Position - view.Selection.Start.Position);
+                view.TextBuffer.Replace(replacementSpan, newText);
+            });
+
         public string GetCurrentLineText()
             => ExecuteOnActiveView(view =>
             {
@@ -99,6 +117,20 @@ public string GetCurrentLineText()
                 return line.GetText();
             });
 
+        public int GetLine()
+            => ExecuteOnActiveView(view =>
+            {
+                view.Caret.Position.BufferPosition.GetLineAndColumn(out int lineNumber, out int columnIndex);
+                return lineNumber;
+            });
+
+        public int GetColumn()
+            => ExecuteOnActiveView(view =>
+            {
+                view.Caret.Position.BufferPosition.GetLineAndColumn(out int lineNumber, out int columnIndex);
+                return columnIndex;
+            });
+
         public string GetLineTextBeforeCaret()
             => ExecuteOnActiveView(view =>
             {
@@ -670,5 +702,12 @@ public int[] GetTagSpans(string tagId)
 
                 return matchingTags.Select(t => t.Span.GetSpans(view.TextBuffer).Single().Span.ToTextSpan()).SelectMany(t => new List<int> { t.Start, t.Length }).ToArray();
             });
+
+        public void SendExplicitFocus()
+            => InvokeOnUIThread(() =>
+            {
+                var view = GetActiveVsTextView();
+                view.SendExplicitFocus();
+            });
     }
 }
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/LocalsWindow_InProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/LocalsWindow_InProc.cs
new file mode 100644
index 0000000000000..dc952b1ede9f5
--- /dev/null
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/LocalsWindow_InProc.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using EnvDTE80;
+
+namespace Microsoft.VisualStudio.IntegrationTest.Utilities.InProcess
+{
+    internal class LocalsWindow_InProc : InProcComponent
+    {
+        public static LocalsWindow_InProc Create() => new LocalsWindow_InProc();
+
+        public Common.Expression GetEntry(string entryName)
+        {
+            var dte = ((DTE2)GetDTE());
+            if (dte.Debugger.CurrentStackFrame != null) // Ensure that debugger is running
+            {
+                EnvDTE.Expressions locals = dte.Debugger.CurrentStackFrame.Locals;
+                foreach (EnvDTE.Expression local in locals)
+                {
+                    if (local.Name == entryName)
+                    {
+                        return new Common.Expression(local);
+                    }
+                }
+            }
+
+            throw new Exception($"Could not find the local named {entryName}.");
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/VisualStudio_InProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/VisualStudio_InProc.cs
index 58d6202387d01..3066e17b38ca9 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/VisualStudio_InProc.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/VisualStudio_InProc.cs
@@ -47,7 +47,7 @@ public string[] GetAvailableCommands()
             return result.ToArray();
         }
 
-        public void ActivateMainWindow()
+        public void ActivateMainWindow(bool skipAttachingThreads = false)
             => InvokeOnUIThread(() => {
                 var dte = GetDTE();
 
@@ -60,7 +60,7 @@ public void ActivateMainWindow()
                     Debug.WriteLine($"DTE.MainWindow.HWnd = {activeVisualStudioWindow}");
                 }
 
-                IntegrationHelper.SetForegroundWindow(activeVisualStudioWindow);
+                IntegrationHelper.SetForegroundWindow(activeVisualStudioWindow, skipAttachingThreads);
             });
 
         public int GetErrorListErrorCount()
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/IntegrationHelper.cs b/src/VisualStudio/IntegrationTest/TestUtilities/IntegrationHelper.cs
index 5aeb931844402..30aca200a733d 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/IntegrationHelper.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/IntegrationHelper.cs
@@ -217,7 +217,7 @@ public static void KillProcess(string processName)
             }
         }
 
-        public static void SetForegroundWindow(IntPtr window)
+        public static void SetForegroundWindow(IntPtr window, bool skipAttachingThread = false)
         {
             var foregroundWindow = GetForegroundWindow();
 
@@ -233,8 +233,12 @@ public static void SetForegroundWindow(IntPtr window)
 
             try
             {
-                // Attach the thread inputs so that 'SetActiveWindow' and 'SetFocus' work
-                threadInputsAttached = AttachThreadInput(currentThreadId, activeThreadId);
+                // No need to re-attach threads in case when VS initializaed an UI thread for a debugged application.
+                if (!skipAttachingThread)
+                {
+                    // Attach the thread inputs so that 'SetActiveWindow' and 'SetFocus' work
+                    threadInputsAttached = AttachThreadInput(currentThreadId, activeThreadId);
+                }
 
                 // Make the window a top-most window so it will appear above any existing top-most windows
                 NativeMethods.SetWindowPos(window, (IntPtr)NativeMethods.HWND_TOPMOST, 0, 0, 0, 0, (NativeMethods.SWP_NOSIZE | NativeMethods.SWP_NOMOVE));
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Debugger_OutOfProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Debugger_OutOfProc.cs
new file mode 100644
index 0000000000000..91987fb488043
--- /dev/null
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Debugger_OutOfProc.cs
@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.VisualStudio.IntegrationTest.Utilities.InProcess;
+using Xunit;
+
+namespace Microsoft.VisualStudio.IntegrationTest.Utilities.OutOfProcess
+{
+    /// <summary>
+    /// Provides a means of interacting with the Visual Studio debugger by remoting calls into Visual Studio.
+    /// </summary>
+    public partial class Debugger_OutOfProc : OutOfProcComponent
+    {
+        private readonly Debugger_InProc _debuggerInProc;
+        private readonly VisualStudioInstance _instance;
+
+        public Debugger_OutOfProc(VisualStudioInstance visualStudioInstance) : base(visualStudioInstance)
+        {
+            _instance = visualStudioInstance;
+            _debuggerInProc = CreateInProcComponent<Debugger_InProc>(visualStudioInstance);
+        }
+
+        public void SetBreakPoint(string fileName, int lineNumber, int columnIndex)  => 
+            _debuggerInProc.SetBreakPoint(fileName, lineNumber, columnIndex);
+
+        public void SetBreakPoint(string fileName, string text, int charsOffset = 0)
+        {
+            _instance.Editor.SelectTextInCurrentDocument(text);
+            int lineNumber = _instance.Editor.GetLine();
+            int columnIndex = _instance.Editor.GetColumn();
+
+            SetBreakPoint(fileName, lineNumber, columnIndex + charsOffset);
+        }
+
+        public void Go(bool waitForBreakMode) => _debuggerInProc.Go(waitForBreakMode);
+
+        public void StepOver(bool waitForBreakOrEnd) => _debuggerInProc.StepOver(waitForBreakOrEnd);
+
+        public void Stop(bool waitForDesignMode) => _debuggerInProc.Stop(waitForDesignMode);
+
+        public void SetNextStatement() => _debuggerInProc.SetNextStatement();
+
+        public void ExecuteStatement(string statement) => _debuggerInProc.ExecuteStatement(statement);
+
+        public void CheckExpression(string expressionText, string expectedType, string expectedValue)
+        {
+            var entry = _debuggerInProc.GetExpression(expressionText);
+            Assert.Equal(expectedType, entry.Type);
+            Assert.Equal(expectedValue, entry.Value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Dialog_OutOfProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Dialog_OutOfProc.cs
new file mode 100644
index 0000000000000..bf3c528a6c01e
--- /dev/null
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Dialog_OutOfProc.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+namespace Microsoft.VisualStudio.IntegrationTest.Utilities.OutOfProcess
+{
+    public class Dialog_OutOfProc : OutOfProcComponent
+    {
+        public Dialog_OutOfProc(VisualStudioInstance visualStudioInstance) 
+            : base(visualStudioInstance)
+        {
+        }
+
+        public void VerifyOpen(string dialogName)
+        {
+            // FindDialog will wait until the dialog is open, so the return value is unused.
+            DialogHelpers.FindDialogByName(GetMainWindowHWnd(), dialogName, isOpen: true);
+        }
+
+        public void VerifyClosed(string dialogName)
+        {
+            // FindDialog will wait until the dialog is closed, so the return value is unused.
+            DialogHelpers.FindDialogByName(GetMainWindowHWnd(), dialogName, isOpen: false);
+        }
+
+        public void Click(string dialogName, string buttonName)
+            => DialogHelpers.PressButtonWithNameFromDialogWithName(GetMainWindowHWnd(), dialogName, buttonName);
+
+        private int GetMainWindowHWnd()
+            => VisualStudioInstance.Shell.GetHWnd();
+    }
+}
\ No newline at end of file
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Editor_OutOfProc.Verifier.cs b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Editor_OutOfProc.Verifier.cs
index 72bc88f457edd..3f98699bb715a 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Editor_OutOfProc.Verifier.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Editor_OutOfProc.Verifier.cs
@@ -194,6 +194,11 @@ public void ErrorTags(params string[] expectedTags)
                 var actualTags = _textViewWindow.GetErrorTags();
                 Assert.Equal(expectedTags, actualTags);
             }
+
+            public void IsProjectItemDirty(bool expectedValue)
+            {
+                Assert.Equal(expectedValue, _textViewWindow._editorInProc.IsProjectItemDirty());
+            }
         }
     }
 }
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Editor_OutOfProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Editor_OutOfProc.cs
index 0b68f0c090d8c..a96117770d89f 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Editor_OutOfProc.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Editor_OutOfProc.cs
@@ -127,12 +127,19 @@ public void SelectTextInCurrentDocument(string text)
             PlaceCaret(text, charsOffset: 0, occurrence: 0, extendSelection: true, selectBlock: false);
         }
 
+        public int GetLine() => _editorInProc.GetLine();
+
+        public int GetColumn() => _editorInProc.GetColumn();
+
         public void DeleteText(string text)
         {
             SelectTextInCurrentDocument(text);
             SendKeys(VirtualKey.Delete);
         }
 
+        public void ReplaceText(string oldText, string newText)
+            => _editorInProc.ReplaceText(oldText, newText);
+
         public bool IsCaretOnScreen()
             => _editorInProc.IsCaretOnScreen();
 
@@ -324,5 +331,8 @@ public void GoToDefinition()
 
         public void GoToImplementation()
             => _editorInProc.GoToImplementation();
+
+        public void SendExplicitFocus()
+            => _editorInProc.SendExplicitFocus();
     }
 }
\ No newline at end of file
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/ErrorList_OutOfProc.Verifier.cs b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/ErrorList_OutOfProc.Verifier.cs
index 6159b9d754672..b3598f2cc61bf 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/ErrorList_OutOfProc.Verifier.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/ErrorList_OutOfProc.Verifier.cs
@@ -21,6 +21,11 @@ public Verifier(ErrorList_OutOfProc errorList, VisualStudioInstance instance)
             public void NoBuildErrors()
             {
                 _instance.SolutionExplorer.BuildSolution(waitForBuildToFinish: true);
+                NoErrors();
+            }
+
+            public void NoErrors()
+            {
                 Assert.Equal(0, _errorList.GetErrorListErrorCount());
             }
         }
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/LocalsWindow_OutOfProc.Verifier.cs b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/LocalsWindow_OutOfProc.Verifier.cs
new file mode 100644
index 0000000000000..43b3512651eff
--- /dev/null
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/LocalsWindow_OutOfProc.Verifier.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Xunit;
+
+namespace Microsoft.VisualStudio.IntegrationTest.Utilities.OutOfProcess
+{
+    public partial class LocalsWindow_OutOfProc
+    {
+        public class Verifier
+        {
+            private readonly LocalsWindow_OutOfProc _localsWindow;
+
+            public Verifier(LocalsWindow_OutOfProc localsWindow)
+            {
+                _localsWindow = localsWindow;
+            }
+
+            public void CheckEntry(string entryName, string expectedType, string expectedValue)
+            {
+                var entry =_localsWindow._localsWindowInProc.GetEntry(entryName);
+                Assert.Equal(expectedType, entry.Type);
+                Assert.Equal(expectedValue, entry.Value);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/LocalsWindow_OutOfProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/LocalsWindow_OutOfProc.cs
new file mode 100644
index 0000000000000..f9bf5ded7f801
--- /dev/null
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/LocalsWindow_OutOfProc.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.VisualStudio.IntegrationTest.Utilities.InProcess;
+
+namespace Microsoft.VisualStudio.IntegrationTest.Utilities.OutOfProcess
+{
+    public partial class LocalsWindow_OutOfProc : OutOfProcComponent
+    {
+        public Verifier Verify { get; }
+
+        private readonly LocalsWindow_InProc _localsWindowInProc;
+
+        public LocalsWindow_OutOfProc(VisualStudioInstance visualStudioInstance) : base(visualStudioInstance)
+        {
+            _localsWindowInProc = CreateInProcComponent<LocalsWindow_InProc>(visualStudioInstance);
+            Verify = new Verifier(this);
+        }
+    }
+}
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioInstance.cs b/src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioInstance.cs
index 3c0ca3f7d88c5..c06bb58536ecf 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioInstance.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioInstance.cs
@@ -25,6 +25,10 @@ public class VisualStudioInstance
 
         public CSharpInteractiveWindow_OutOfProc InteractiveWindow { get; }
 
+        public Debugger_OutOfProc Debugger { get; }
+
+        public Dialog_OutOfProc Dialog { get; }
+
         public Editor_OutOfProc Editor { get; }
 
         public EncapsulateField_OutOfProc EncapsulateField { get; }
@@ -39,6 +43,8 @@ public class VisualStudioInstance
 
         public InlineRenameDialog_OutOfProc InlineRenameDialog { get; set; }
 
+        public LocalsWindow_OutOfProc LocalsWindow { get; set; }
+
         public PreviewChangesDialog_OutOfProc PreviewChangesDialog { get; }
 
         public SendKeys SendKeys { get; }
@@ -91,6 +97,8 @@ public VisualStudioInstance(Process hostProcess, DTE dte, ImmutableHashSet<strin
 
             ChangeSignatureDialog = new ChangeSignatureDialog_OutOfProc(this);
             InteractiveWindow = new CSharpInteractiveWindow_OutOfProc(this);
+            Debugger = new Debugger_OutOfProc(this);
+            Dialog = new Dialog_OutOfProc(this);
             Editor = new Editor_OutOfProc(this);
             EncapsulateField = new EncapsulateField_OutOfProc(this);
             ErrorList = new ErrorList_OutOfProc(this);
@@ -98,6 +106,7 @@ public VisualStudioInstance(Process hostProcess, DTE dte, ImmutableHashSet<strin
             FindReferencesWindow = new FindReferencesWindow_OutOfProc(this);
             GenerateTypeDialog = new GenerateTypeDialog_OutOfProc(this);
             InlineRenameDialog = new InlineRenameDialog_OutOfProc(this);
+            LocalsWindow = new LocalsWindow_OutOfProc(this);
             PreviewChangesDialog = new PreviewChangesDialog_OutOfProc(this);
             Shell = new Shell_OutOfProc(this);
             SolutionExplorer = new SolutionExplorer_OutOfProc(this);
@@ -125,8 +134,8 @@ public T ExecuteInHostProcess<T>(Type type, string methodName)
             return (T)Activator.GetObject(typeof(T), $"{_integrationService.BaseUri}/{objectUri}");
         }
 
-        public void ActivateMainWindow()
-            => _inProc.ActivateMainWindow();
+        public void ActivateMainWindow(bool skipAttachingThreads = false)
+            => _inProc.ActivateMainWindow(skipAttachingThreads);
 
         public void WaitForApplicationIdle()
             => _inProc.WaitForApplicationIdle();
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioIntegrationTestUtilities.csproj b/src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioIntegrationTestUtilities.csproj
index 14769b8476d50..d621c7c85d0ac 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioIntegrationTestUtilities.csproj
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioIntegrationTestUtilities.csproj
@@ -28,15 +28,18 @@
     <Compile Include="CaptureTestNameAttribute.cs" />
     <Compile Include="Common\Comparison.cs" />
     <Compile Include="Common\ErrorListItem.cs" />
+    <Compile Include="Common\Expression.cs" />
     <Compile Include="Common\Parameter.cs" />
     <Compile Include="Common\ProjectUtilities.cs" />
     <Compile Include="Common\Reference.cs" />
     <Compile Include="Common\Signature.cs" />
     <Compile Include="Helper.cs" />
     <Compile Include="HostWaitHelper.cs" />
+    <Compile Include="InProcess\Debugger_InProc.cs" />
     <Compile Include="InProcess\Editor_InProc_NavigationBar.cs" />
     <Compile Include="InProcess\ErrorList_InProc.cs" />
     <Compile Include="Common\ClassifiedToken.cs" />
+    <Compile Include="InProcess\LocalsWindow_InProc.cs" />
     <Compile Include="InProcess\TextViewWindow_InProc.cs" />
     <Compile Include="InProcess\CSharpInteractiveWindow_InProc.cs" />
     <Compile Include="DialogHelpers.cs" />
@@ -54,11 +57,15 @@
     <Compile Include="InProcess\Editor_InProc.cs" />
     <Compile Include="Interop\NativeMethods.cs" />
     <Compile Include="LightBulbHelper.cs" />
+    <Compile Include="OutOfProcess\Dialog_OutOfProc.cs" />
+    <Compile Include="OutOfProcess\Debugger_OutOfProc.cs" />
     <Compile Include="OutOfProcess\InlineRenameDialog_OutOfProc.cs" />
     <Compile Include="OutOfProcess\ChangeSignatureDialog_OutOfProc.cs" />
     <Compile Include="OutOfProcess\Editor_OutOfProc.Verifier.cs" />
     <Compile Include="OutOfProcess\ErrorList_OutOfProc.Verifier.cs" />
     <Compile Include="OutOfProcess\InteractiveWindow_OutOfProc.Verifier.cs" />
+    <Compile Include="OutOfProcess\LocalsWindow_OutOfProc.cs" />
+    <Compile Include="OutOfProcess\LocalsWindow_OutOfProc.Verifier.cs" />
     <Compile Include="OutOfProcess\SolutionExplorer_OutOfProc.Verifier.cs" />
     <Compile Include="OutOfProcess\TextViewWindow_OutOfProc.Verifier.cs" />
     <Compile Include="OutOfProcess\EncapsulateField_OutOfProc.cs" />

From 6a3f93458b173804209dc773283cc76d74907b0b Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Wed, 10 May 2017 13:56:11 -0700
Subject: [PATCH 103/284] added more comments

---
 .../Core/Portable/Execution/PinnedRemotableDataScope.cs        | 3 +++
 .../Remote/ServiceHub/Shared/ServiceHubServiceBase.cs          | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs b/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs
index f09b9ada783c5..42504565df844 100644
--- a/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs
+++ b/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs
@@ -35,6 +35,9 @@ public PinnedRemotableDataScope(
 
         /// <summary>
         /// This indicates whether this scope is for primary branch or not (not forked solution)
+        /// 
+        /// Features like OOP will use this flag to see whether caching information related to this solution
+        /// can benefit other requests or not
         /// </summary>
         public bool ForPrimaryBranch => _storage.SolutionState.BranchId == Workspace.PrimaryBranchId;
 
diff --git a/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs b/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs
index a02a3ca22f613..9fe7c75f4e5a4 100644
--- a/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs
+++ b/src/Workspaces/Remote/ServiceHub/Shared/ServiceHubServiceBase.cs
@@ -34,6 +34,9 @@ internal abstract class ServiceHubServiceBase : IDisposable
 
         /// <summary>
         /// Mark whether the solution checksum it got is for primary branch or not
+        /// 
+        /// this flag will be passed down to solution controller to help
+        /// solution service's cache policy. for more detail, see <see cref="SolutionService"/>
         /// </summary>
         private bool _fromPrimaryBranch;
 

From 11f3f8abdf68ae34dd3a2350807367cf0223291b Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Wed, 10 May 2017 14:00:19 -0700
Subject: [PATCH 104/284] add assert

---
 .../Core/Portable/Execution/PinnedRemotableDataScope.cs         | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs b/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs
index 42504565df844..995c8c30e25aa 100644
--- a/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs
+++ b/src/Workspaces/Core/Portable/Execution/PinnedRemotableDataScope.cs
@@ -25,6 +25,8 @@ public PinnedRemotableDataScope(
             AssetStorages.Storage storage,
             Checksum solutionChecksum)
         {
+            Contract.ThrowIfNull(solutionChecksum);
+
             _storages = storages;
             _storage = storage;
 

From 934fbe934b4833e8cf991a3fdfdd3170fc0313a1 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 14:21:16 -0700
Subject: [PATCH 105/284] Createing indices for metadata can fail.  Be
 resilient to that.

---
 ...ymbolTreeInfoIncrementalAnalyzerProvider.cs | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs b/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
index 6b961a156ffdf..50a4a27e38837 100644
--- a/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
+++ b/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
@@ -4,6 +4,7 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Composition;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -42,7 +43,7 @@ private struct MetadataInfo
             /// Note: can be <code>null</code> if were unable to create a SymbolTreeInfo
             /// (for example, if the metadata was bogus and we couldn't read it in).
             /// </summary>
-            public readonly SymbolTreeInfo SymbolTreeInfo;
+            public readonly SymbolTreeInfo SymbolTreeInfoOpt;
 
             /// <summary>
             /// Note: the Incremental-Analyzer infrastructure guarantees that it will call all the methods
@@ -53,7 +54,7 @@ private struct MetadataInfo
 
             public MetadataInfo(SymbolTreeInfo info, HashSet<ProjectId> referencingProjects)
             {
-                SymbolTreeInfo = info;
+                SymbolTreeInfoOpt = info;
                 ReferencingProjects = referencingProjects;
             }
         }
@@ -114,9 +115,9 @@ public async Task<SymbolTreeInfo> TryGetMetadataSymbolTreeInfoAsync(
                 if (key != null)
                 {
                     if (_metadataPathToInfo.TryGetValue(key, out var metadataInfo) &&
-                        metadataInfo.SymbolTreeInfo.Checksum == checksum)
+                        metadataInfo.SymbolTreeInfoOpt?.Checksum == checksum)
                     {
-                        return metadataInfo.SymbolTreeInfo;
+                        return metadataInfo.SymbolTreeInfoOpt;
                     }
                 }
 
@@ -194,11 +195,6 @@ private async Task UpdateSymbolTreeInfoAsync(Project project, CancellationToken
                     return;
                 }
 
-                if (!project.SupportsCompilation)
-                {
-                    return;
-                }
-
                 // Produce the indices for the source and metadata symbols in parallel.
                 var projectTask = UpdateSourceSymbolTreeInfoAsync(project, cancellationToken);
                 var referencesTask = UpdateReferencesAync(project, cancellationToken);
@@ -215,6 +211,8 @@ private async Task UpdateSourceSymbolTreeInfoAsync(Project project, Cancellation
                     projectInfo = await SymbolTreeInfo.GetInfoForSourceAssemblyAsync(
                         project, checksum, cancellationToken).ConfigureAwait(false);
 
+                    Debug.Assert(projectInfo != null);
+
                     // Mark that we're up to date with this project.  Future calls with the same 
                     // semantic version can bail out immediately.
                     _projectToInfo.AddOrUpdate(project.Id, projectInfo, (_1, _2) => projectInfo);
@@ -242,7 +240,7 @@ private async Task UpdateReferenceAsync(
 
                 var checksum = SymbolTreeInfo.GetMetadataChecksum(project.Solution, reference, cancellationToken);
                 if (!_metadataPathToInfo.TryGetValue(key, out var metadataInfo) ||
-                    metadataInfo.SymbolTreeInfo.Checksum != checksum)
+                    metadataInfo.SymbolTreeInfoOpt?.Checksum != checksum)
                 {
                     var info = await SymbolTreeInfo.TryGetInfoForMetadataReferenceAsync(
                         project.Solution, reference, checksum, loadOnly: false, cancellationToken: cancellationToken).ConfigureAwait(false);

From 737d993c1e67d42e9b86e9cd4e6f5a7d0bbe8a7e Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 14:28:34 -0700
Subject: [PATCH 106/284] Store a copy of the checksum as we may have failed to
 create an index for a piece of metadata.

---
 ...mbolTreeInfoIncrementalAnalyzerProvider.cs | 25 +++++++++++++++----
 1 file changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs b/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
index 50a4a27e38837..53fe078fd37f8 100644
--- a/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
+++ b/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
@@ -39,6 +39,15 @@ internal class SymbolTreeInfoIncrementalAnalyzerProvider : IIncrementalAnalyzerP
     {
         private struct MetadataInfo
         {
+            /// <summary>
+            /// The metadata checksum that we calcuated when we computed this MetadataInfo.
+            /// Note: this should be the same as <see cref="SymbolTreeInfoOpt"/>.<see cref="SymbolTreeInfo.Checksum"/>
+            /// *when* <see cref="SymbolTreeInfoOpt"/> is not null.  We have to store this
+            /// in ourself so that we don't keep trying to recompute the index for a piece
+            /// of metadata that we failed to produce a <see cref="SymbolTreeInfo"/> for.
+            /// </summary>
+            public readonly Checksum Checksum;
+
             /// <summary>
             /// Note: can be <code>null</code> if were unable to create a SymbolTreeInfo
             /// (for example, if the metadata was bogus and we couldn't read it in).
@@ -52,8 +61,13 @@ private struct MetadataInfo
             /// </summary>
             public readonly HashSet<ProjectId> ReferencingProjects;
 
-            public MetadataInfo(SymbolTreeInfo info, HashSet<ProjectId> referencingProjects)
+            public MetadataInfo(Checksum checksum, SymbolTreeInfo info, HashSet<ProjectId> referencingProjects)
             {
+                Contract.ThrowIfNull(checksum);
+                Contract.ThrowIfTrue(info != null && info.Checksum != checksum,
+                    "If we computed a SymbolTreeInfo, then it's checksum much match our checksum.");
+
+                Checksum = checksum;
                 SymbolTreeInfoOpt = info;
                 ReferencingProjects = referencingProjects;
             }
@@ -115,7 +129,7 @@ public async Task<SymbolTreeInfo> TryGetMetadataSymbolTreeInfoAsync(
                 if (key != null)
                 {
                     if (_metadataPathToInfo.TryGetValue(key, out var metadataInfo) &&
-                        metadataInfo.SymbolTreeInfoOpt?.Checksum == checksum)
+                        metadataInfo.Checksum == checksum)
                     {
                         return metadataInfo.SymbolTreeInfoOpt;
                     }
@@ -211,7 +225,8 @@ private async Task UpdateSourceSymbolTreeInfoAsync(Project project, Cancellation
                     projectInfo = await SymbolTreeInfo.GetInfoForSourceAssemblyAsync(
                         project, checksum, cancellationToken).ConfigureAwait(false);
 
-                    Debug.Assert(projectInfo != null);
+                    Contract.ThrowIfNull(projectInfo);
+                    Contract.ThrowIfTrue(projectInfo.Checksum != checksum, "If we computed a SymbolTreeInfo, then it's checksum much match our checksum.");
 
                     // Mark that we're up to date with this project.  Future calls with the same 
                     // semantic version can bail out immediately.
@@ -240,7 +255,7 @@ private async Task UpdateReferenceAsync(
 
                 var checksum = SymbolTreeInfo.GetMetadataChecksum(project.Solution, reference, cancellationToken);
                 if (!_metadataPathToInfo.TryGetValue(key, out var metadataInfo) ||
-                    metadataInfo.SymbolTreeInfoOpt?.Checksum != checksum)
+                    metadataInfo.Checksum != checksum)
                 {
                     var info = await SymbolTreeInfo.TryGetInfoForMetadataReferenceAsync(
                         project.Solution, reference, checksum, loadOnly: false, cancellationToken: cancellationToken).ConfigureAwait(false);
@@ -248,7 +263,7 @@ private async Task UpdateReferenceAsync(
                     // Note, getting the info may fail (for example, bogus metadata).  That's ok.  
                     // We still want to cache that result so that don't try to continuously produce
                     // this info over and over again.
-                    metadataInfo = new MetadataInfo(info, metadataInfo.ReferencingProjects ?? new HashSet<ProjectId>());
+                    metadataInfo = new MetadataInfo(checksum, info, metadataInfo.ReferencingProjects ?? new HashSet<ProjectId>());
                     _metadataPathToInfo.AddOrUpdate(key, metadataInfo, (_1, _2) => metadataInfo);
                 }
 

From 174035e6e9774b024bb07b6a67ee1298e83948cc Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Wed, 10 May 2017 14:56:17 -0700
Subject: [PATCH 107/284] fix build break.

---
 src/Workspaces/Remote/Core/Services/SolutionCreator.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/Remote/Core/Services/SolutionCreator.cs b/src/Workspaces/Remote/Core/Services/SolutionCreator.cs
index a785663ffafeb..2ea7c774bd1d3 100644
--- a/src/Workspaces/Remote/Core/Services/SolutionCreator.cs
+++ b/src/Workspaces/Remote/Core/Services/SolutionCreator.cs
@@ -616,7 +616,7 @@ private ImmutableArray<string> GetStrongNameKeyPaths(ProjectInfo.ProjectAttribut
         private async Task ValidateChecksumAsync(Checksum givenSolutionChecksum, Solution solution)
         {
             // have this to avoid error on async
-            await SpecializedTasks.EmptyTask;
+            await SpecializedTasks.EmptyTask.ConfigureAwait(false);
 
 #if DEBUG
             var currentSolutionChecksum = await solution.State.GetChecksumAsync(_cancellationToken).ConfigureAwait(false);

From a785172867b340542dfc7162564d1dce3c7f3b07 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 15:00:28 -0700
Subject: [PATCH 108/284] Take an approach where we cannot get Null Symbol Tree
 infos.

---
 ...mbolTreeInfoIncrementalAnalyzerProvider.cs | 40 +++++++------------
 .../Declarations/DeclarationFinder.cs         | 10 ++---
 .../FindReferences/DependentTypeFinder.cs     |  6 +--
 .../FindSymbols/SymbolTree/SymbolTreeInfo.cs  | 13 +++++-
 .../SymbolTree/SymbolTreeInfo_Metadata.cs     | 27 ++++++-------
 .../SymbolTreeInfo_Serialization.cs           | 21 +++++-----
 .../SymbolTree/SymbolTreeInfo_Source.cs       | 10 ++---
 7 files changed, 59 insertions(+), 68 deletions(-)

diff --git a/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs b/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
index 53fe078fd37f8..cdf69e1500b48 100644
--- a/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
+++ b/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
@@ -40,19 +40,10 @@ internal class SymbolTreeInfoIncrementalAnalyzerProvider : IIncrementalAnalyzerP
         private struct MetadataInfo
         {
             /// <summary>
-            /// The metadata checksum that we calcuated when we computed this MetadataInfo.
-            /// Note: this should be the same as <see cref="SymbolTreeInfoOpt"/>.<see cref="SymbolTreeInfo.Checksum"/>
-            /// *when* <see cref="SymbolTreeInfoOpt"/> is not null.  We have to store this
-            /// in ourself so that we don't keep trying to recompute the index for a piece
-            /// of metadata that we failed to produce a <see cref="SymbolTreeInfo"/> for.
+            /// Can't be null.  Even if we weren't able to read in metadata, we'll still create an empty
+            /// index.
             /// </summary>
-            public readonly Checksum Checksum;
-
-            /// <summary>
-            /// Note: can be <code>null</code> if were unable to create a SymbolTreeInfo
-            /// (for example, if the metadata was bogus and we couldn't read it in).
-            /// </summary>
-            public readonly SymbolTreeInfo SymbolTreeInfoOpt;
+            public readonly SymbolTreeInfo SymbolTreeInfo;
 
             /// <summary>
             /// Note: the Incremental-Analyzer infrastructure guarantees that it will call all the methods
@@ -61,14 +52,10 @@ private struct MetadataInfo
             /// </summary>
             public readonly HashSet<ProjectId> ReferencingProjects;
 
-            public MetadataInfo(Checksum checksum, SymbolTreeInfo info, HashSet<ProjectId> referencingProjects)
+            public MetadataInfo(SymbolTreeInfo info, HashSet<ProjectId> referencingProjects)
             {
-                Contract.ThrowIfNull(checksum);
-                Contract.ThrowIfTrue(info != null && info.Checksum != checksum,
-                    "If we computed a SymbolTreeInfo, then it's checksum much match our checksum.");
-
-                Checksum = checksum;
-                SymbolTreeInfoOpt = info;
+                Contract.ThrowIfNull(info);
+                SymbolTreeInfo = info;
                 ReferencingProjects = referencingProjects;
             }
         }
@@ -129,16 +116,16 @@ public async Task<SymbolTreeInfo> TryGetMetadataSymbolTreeInfoAsync(
                 if (key != null)
                 {
                     if (_metadataPathToInfo.TryGetValue(key, out var metadataInfo) &&
-                        metadataInfo.Checksum == checksum)
+                        metadataInfo.SymbolTreeInfo.Checksum == checksum)
                     {
-                        return metadataInfo.SymbolTreeInfoOpt;
+                        return metadataInfo.SymbolTreeInfo;
                     }
                 }
 
                 // If we didn't have it in our cache, see if we can load it from disk.
                 // Note: pass 'loadOnly' so we only attempt to load from disk, not to actually
                 // try to create the metadata.
-                var info = await SymbolTreeInfo.TryGetInfoForMetadataReferenceAsync(
+                var info = await SymbolTreeInfo.GetInfoForMetadataReferenceAsync(
                     solution, reference, checksum, loadOnly: true, cancellationToken: cancellationToken).ConfigureAwait(false);
                 return info;
             }
@@ -255,15 +242,18 @@ private async Task UpdateReferenceAsync(
 
                 var checksum = SymbolTreeInfo.GetMetadataChecksum(project.Solution, reference, cancellationToken);
                 if (!_metadataPathToInfo.TryGetValue(key, out var metadataInfo) ||
-                    metadataInfo.Checksum != checksum)
+                    metadataInfo.SymbolTreeInfo.Checksum != checksum)
                 {
-                    var info = await SymbolTreeInfo.TryGetInfoForMetadataReferenceAsync(
+                    var info = await SymbolTreeInfo.GetInfoForMetadataReferenceAsync(
                         project.Solution, reference, checksum, loadOnly: false, cancellationToken: cancellationToken).ConfigureAwait(false);
 
+                    Contract.ThrowIfNull(info);
+                    Contract.ThrowIfTrue(info.Checksum != checksum, "If we computed a SymbolTreeInfo, then it's checksum much match our checksum.");
+
                     // Note, getting the info may fail (for example, bogus metadata).  That's ok.  
                     // We still want to cache that result so that don't try to continuously produce
                     // this info over and over again.
-                    metadataInfo = new MetadataInfo(checksum, info, metadataInfo.ReferencingProjects ?? new HashSet<ProjectId>());
+                    metadataInfo = new MetadataInfo(info, metadataInfo.ReferencingProjects ?? new HashSet<ProjectId>());
                     _metadataPathToInfo.AddOrUpdate(key, metadataInfo, (_1, _2) => metadataInfo);
                 }
 
diff --git a/src/Workspaces/Core/Portable/FindSymbols/Declarations/DeclarationFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/Declarations/DeclarationFinder.cs
index da95fee4a35c0..3206101af27ec 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/Declarations/DeclarationFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/Declarations/DeclarationFinder.cs
@@ -74,14 +74,12 @@ private static async Task AddMetadataDeclarationsWithNormalQueryAsync(
             {
                 if (referenceOpt != null)
                 {
-                    var info = await SymbolTreeInfo.TryGetInfoForMetadataReferenceAsync(
+                    var info = await SymbolTreeInfo.GetInfoForMetadataReferenceAsync(
                         project.Solution, referenceOpt, loadOnly: false, cancellationToken: cancellationToken).ConfigureAwait(false);
-                    if (info != null)
-                    {
-                        var symbols = await info.FindAsync(
+
+                    var symbols = await info.FindAsync(
                             query, assembly, project.Id, filter, cancellationToken).ConfigureAwait(false);
-                        list.AddRange(symbols);
-                    }
+                    list.AddRange(symbols);
                 }
             }
         }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentTypeFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentTypeFinder.cs
index b5a1cf9179d3c..37cf8cfeb9ba8 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentTypeFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentTypeFinder.cs
@@ -469,12 +469,8 @@ private static async Task FindImmediateMatchingMetadataTypesInMetadataReferenceA
             // implement that type.  Because the mapping is from the simple name
             // we might get false positives.  But that's fine as we still use 
             // 'metadataTypeMatches' to make sure the match is correct.
-            var symbolTreeInfo = await SymbolTreeInfo.TryGetInfoForMetadataReferenceAsync(
+            var symbolTreeInfo = await SymbolTreeInfo.GetInfoForMetadataReferenceAsync(
                 project.Solution, reference, loadOnly: false, cancellationToken: cancellationToken).ConfigureAwait(false);
-            if (symbolTreeInfo == null)
-            {
-                return;
-            }
 
             // For each type we care about, see if we can find any derived types
             // in this index.
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs
index b7bd6d9184ed3..88a743df9e63e 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs
@@ -105,7 +105,7 @@ private SymbolTreeInfo(
         private SymbolTreeInfo(
             Checksum checksum,
             string concatenatedNames,
-            Node[] sortedNodes, 
+            Node[] sortedNodes,
             Task<SpellChecker> spellCheckerTask)
         {
             Checksum = checksum;
@@ -114,6 +114,15 @@ private SymbolTreeInfo(
             _spellCheckerTask = spellCheckerTask;
         }
 
+        public static SymbolTreeInfo CreateEmpty(Checksum checksum)
+        {
+            var unsortedNodes = ImmutableArray.Create(new BuilderNode(name: "", parentIndex: RootNodeParentIndex));
+            SortNodes(unsortedNodes, out var concatenatedNames, out var sortedNodes);
+
+            return new SymbolTreeInfo(checksum, concatenatedNames, sortedNodes,
+                CreateSpellCheckerAsync(checksum, concatenatedNames, sortedNodes));
+        }
+
         public Task<ImmutableArray<SymbolAndProjectId>> FindAsync(
             SearchQuery query, IAssemblySymbol assembly, ProjectId assemblyProjectId, SymbolFilter filter, CancellationToken cancellationToken)
         {
@@ -209,7 +218,7 @@ private async Task<ImmutableArray<ISymbol>> FindAsync(
                 Bind(node, assemblySymbol.GlobalNamespace, results, cancellationToken);
             }
 
-            return results.ToImmutableAndFree(); ;
+            return results.ToImmutableAndFree();
         }
 
         private static StringSliceComparer GetComparer(bool ignoreCase)
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
index 680635d5627ea..923fdd6d9ba3b 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
@@ -59,22 +59,21 @@ private static Metadata GetMetadataNoThrow(PortableExecutableReference reference
             }
         }
 
-        public static Task<SymbolTreeInfo> TryGetInfoForMetadataReferenceAsync(
+        public static Task<SymbolTreeInfo> GetInfoForMetadataReferenceAsync(
             Solution solution, PortableExecutableReference reference,
             bool loadOnly, CancellationToken cancellationToken)
         {
             var checksum = GetMetadataChecksum(solution, reference, cancellationToken);
-            return TryGetInfoForMetadataReferenceAsync(
+            return GetInfoForMetadataReferenceAsync(
                 solution, reference, checksum,
                 loadOnly, cancellationToken);
         }
 
         /// <summary>
         /// Produces a <see cref="SymbolTreeInfo"/> for a given <see cref="PortableExecutableReference"/>.
-        /// Note: can return <code>null</code> if we weren't able to actually load the metadata for some
-        /// reason.
+        /// Note:  will never return null;
         /// </summary>
-        public static Task<SymbolTreeInfo> TryGetInfoForMetadataReferenceAsync(
+        public static Task<SymbolTreeInfo> GetInfoForMetadataReferenceAsync(
             Solution solution,
             PortableExecutableReference reference,
             Checksum checksum,
@@ -84,7 +83,7 @@ public static Task<SymbolTreeInfo> TryGetInfoForMetadataReferenceAsync(
             var metadataId = GetMetadataIdNoThrow(reference);
             if (metadataId == null)
             {
-                return SpecializedTasks.Default<SymbolTreeInfo>();
+                return Task.FromResult(CreateEmpty(checksum));
             }
 
             // Try to acquire the data outside the lock.  That way we can avoid any sort of 
@@ -99,14 +98,14 @@ public static Task<SymbolTreeInfo> TryGetInfoForMetadataReferenceAsync(
             var metadata = GetMetadataNoThrow(reference);
             if (metadata == null)
             {
-                return SpecializedTasks.Default<SymbolTreeInfo>();
+                return Task.FromResult(CreateEmpty(checksum));
             }
 
-            return TryGetInfoForMetadataReferenceSlowAsync(
+            return GetInfoForMetadataReferenceSlowAsync(
                 solution, reference, checksum, loadOnly, metadata, cancellationToken);
         }
 
-        private static async Task<SymbolTreeInfo> TryGetInfoForMetadataReferenceSlowAsync(
+        private static async Task<SymbolTreeInfo> GetInfoForMetadataReferenceSlowAsync(
             Solution solution, PortableExecutableReference reference, Checksum checksum,
             bool loadOnly, Metadata metadata, CancellationToken cancellationToken)
         {
@@ -121,11 +120,11 @@ private static async Task<SymbolTreeInfo> TryGetInfoForMetadataReferenceSlowAsyn
                     return await infoTask.ConfigureAwait(false);
                 }
 
-                var info = await LoadOrCreateMetadataSymbolTreeInfoAsync(
+                var info = await TryLoadOrCreateMetadataSymbolTreeInfoAsync(
                     solution, reference, checksum, loadOnly, cancellationToken).ConfigureAwait(false);
                 if (info == null && loadOnly)
                 {
-                    return null;
+                    return CreateEmpty(checksum);
                 }
 
                 // Cache the result in our dictionary.  Store it as a completed task so that 
@@ -147,7 +146,7 @@ public static Checksum GetMetadataChecksum(
             return checksum;
         }
 
-        private static Task<SymbolTreeInfo> LoadOrCreateMetadataSymbolTreeInfoAsync(
+        private static Task<SymbolTreeInfo> TryLoadOrCreateMetadataSymbolTreeInfoAsync(
             Solution solution,
             PortableExecutableReference reference,
             Checksum checksum,
@@ -156,7 +155,7 @@ private static Task<SymbolTreeInfo> LoadOrCreateMetadataSymbolTreeInfoAsync(
         {
             var filePath = reference.FilePath;
 
-            return LoadOrCreateAsync(
+            return TryLoadOrCreateAsync(
                 solution,
                 checksum,
                 filePath,
@@ -263,7 +262,7 @@ internal SymbolTreeInfo Create()
                 }
 
                 var unsortedNodes = GenerateUnsortedNodes();
-                return SymbolTreeInfo.CreateSymbolTreeInfo(
+                return CreateSymbolTreeInfo(
                     _solution, _checksum, _reference.FilePath, unsortedNodes, _inheritanceMap);
             }
 
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
index d7a9b48c474f5..5d19ceb9081d7 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
@@ -26,7 +26,7 @@ internal partial class SymbolTreeInfo : IObjectWritable
         private static Task<SymbolTreeInfo> LoadOrCreateSourceSymbolTreeInfoAsync(
             Project project, Checksum checksum, bool loadOnly, CancellationToken cancellationToken)
         {
-            return LoadOrCreateAsync(
+            return TryLoadOrCreateAsync(
                 project.Solution,
                 checksum,
                 project.FilePath,
@@ -48,7 +48,7 @@ private static Task<SpellChecker> LoadOrCreateSpellCheckerAsync(
             string filePath,
             Func<Task<SpellChecker>> createAsync)
         {
-            return LoadOrCreateAsync(
+            return TryLoadOrCreateAsync(
                 solution,
                 checksum,
                 filePath,
@@ -64,7 +64,7 @@ private static Task<SpellChecker> LoadOrCreateSpellCheckerAsync(
         /// Generalized function for loading/creating/persisting data.  Used as the common core
         /// code for serialization of SymbolTreeInfos and SpellCheckers.
         /// </summary>
-        private static async Task<T> LoadOrCreateAsync<T>(
+        private static async Task<T> TryLoadOrCreateAsync<T>(
             Solution solution,
             Checksum checksum,
             string filePath,
@@ -116,16 +116,15 @@ private static async Task<T> LoadOrCreateAsync<T>(
 
                 // Now, try to create a new instance and write it to the persistence service.
                 result = await createAsync().ConfigureAwait(false);
-                if (result != null)
+                Contract.ThrowIfNull(result);
+
+                using (var stream = SerializableBytes.CreateWritableStream())
+                using (var writer = new ObjectWriter(stream, cancellationToken: cancellationToken))
                 {
-                    using (var stream = SerializableBytes.CreateWritableStream())
-                    using (var writer = new ObjectWriter(stream, cancellationToken: cancellationToken))
-                    {
-                        result.WriteTo(writer);
-                        stream.Position = 0;
+                    result.WriteTo(writer);
+                    stream.Position = 0;
 
-                        await storage.WriteStreamAsync(key, stream, cancellationToken).ConfigureAwait(false);
-                    }
+                    await storage.WriteStreamAsync(key, stream, cancellationToken).ConfigureAwait(false);
                 }
             }
 
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
index f4a1b4c540f13..8c200861b3b2f 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
@@ -18,9 +18,7 @@ internal partial class SymbolTreeInfo
             new SimplePool<MultiDictionary<string, ISymbol>>(() => new MultiDictionary<string, ISymbol>());
 
         private static MultiDictionary<string, ISymbol> AllocateSymbolMap()
-        {
-            return s_symbolMapPool.Allocate();
-        }
+            => s_symbolMapPool.Allocate();
 
         private static void FreeSymbolMap(MultiDictionary<string, ISymbol> symbolMap)
         {
@@ -31,8 +29,10 @@ private static void FreeSymbolMap(MultiDictionary<string, ISymbol> symbolMap)
         public static Task<SymbolTreeInfo> GetInfoForSourceAssemblyAsync(
             Project project, Checksum checksum, CancellationToken cancellationToken)
         {
-            return LoadOrCreateSourceSymbolTreeInfoAsync(
+            var result = LoadOrCreateSourceSymbolTreeInfoAsync(
                 project, checksum, loadOnly: false, cancellationToken: cancellationToken);
+            Contract.ThrowIfNull(result);
+            return result;
         }
 
         public static async Task<Checksum> GetSourceSymbolsChecksumAsync(Project project, CancellationToken cancellationToken)
@@ -81,7 +81,7 @@ internal static async Task<SymbolTreeInfo> CreateSourceSymbolTreeInfoAsync(
             var assembly = compilation.Assembly;
             if (assembly == null)
             {
-                return null;
+                return CreateEmpty(checksum);
             }
 
             var unsortedNodes = ArrayBuilder<BuilderNode>.GetInstance();

From c10565ecf1d0f769d74f62b373db9d760906b82f Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 15:01:16 -0700
Subject: [PATCH 109/284] Fix grammar.

---
 .../SymbolTreeInfoIncrementalAnalyzerProvider.cs              | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs b/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
index cdf69e1500b48..529898596f1be 100644
--- a/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
+++ b/src/Features/Core/Portable/IncrementalCaches/SymbolTreeInfoIncrementalAnalyzerProvider.cs
@@ -213,7 +213,7 @@ private async Task UpdateSourceSymbolTreeInfoAsync(Project project, Cancellation
                         project, checksum, cancellationToken).ConfigureAwait(false);
 
                     Contract.ThrowIfNull(projectInfo);
-                    Contract.ThrowIfTrue(projectInfo.Checksum != checksum, "If we computed a SymbolTreeInfo, then it's checksum much match our checksum.");
+                    Contract.ThrowIfTrue(projectInfo.Checksum != checksum, "If we computed a SymbolTreeInfo, then its checksum much match our checksum.");
 
                     // Mark that we're up to date with this project.  Future calls with the same 
                     // semantic version can bail out immediately.
@@ -248,7 +248,7 @@ private async Task UpdateReferenceAsync(
                         project.Solution, reference, checksum, loadOnly: false, cancellationToken: cancellationToken).ConfigureAwait(false);
 
                     Contract.ThrowIfNull(info);
-                    Contract.ThrowIfTrue(info.Checksum != checksum, "If we computed a SymbolTreeInfo, then it's checksum much match our checksum.");
+                    Contract.ThrowIfTrue(info.Checksum != checksum, "If we computed a SymbolTreeInfo, then its checksum much match our checksum.");
 
                     // Note, getting the info may fail (for example, bogus metadata).  That's ok.  
                     // We still want to cache that result so that don't try to continuously produce

From 9862f3605f79d50dfc8b6bd67fb11077a73cdf10 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 15:02:59 -0700
Subject: [PATCH 110/284] Share code.

---
 .../Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.Node.cs | 2 ++
 .../Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs      | 2 +-
 .../Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs  | 2 +-
 3 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.Node.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.Node.cs
index acc2c6825c66a..e28d0bd46b879 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.Node.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.Node.cs
@@ -19,6 +19,8 @@ internal partial class SymbolTreeInfo
         [DebuggerDisplay("{GetDebuggerDisplay(),nq}")]
         private struct BuilderNode
         {
+            public static readonly BuilderNode RootNode = new BuilderNode("", RootNodeParentIndex);
+
             public readonly string Name;
             public readonly int ParentIndex;
 
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs
index 88a743df9e63e..e35d3329e8244 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs
@@ -116,7 +116,7 @@ private SymbolTreeInfo(
 
         public static SymbolTreeInfo CreateEmpty(Checksum checksum)
         {
-            var unsortedNodes = ImmutableArray.Create(new BuilderNode(name: "", parentIndex: RootNodeParentIndex));
+            var unsortedNodes = ImmutableArray.Create(BuilderNode.RootNode);
             SortNodes(unsortedNodes, out var concatenatedNames, out var sortedNodes);
 
             return new SymbolTreeInfo(checksum, concatenatedNames, sortedNodes,
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
index 923fdd6d9ba3b..7ca0acbe92aba 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
@@ -634,7 +634,7 @@ private MetadataNode GetOrCreateChildNode(
             private ImmutableArray<BuilderNode> GenerateUnsortedNodes()
             {
                 var unsortedNodes = ArrayBuilder<BuilderNode>.GetInstance();
-                unsortedNodes.Add(new BuilderNode(name: "", parentIndex: RootNodeParentIndex));
+                unsortedNodes.Add(BuilderNode.RootNode);
 
                 AddUnsortedNodes(unsortedNodes, parentNode: _rootNode, parentIndex: 0);
 

From b4c9c9e6c5399dec4016c7e17c3dce80d6880413 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 15:10:29 -0700
Subject: [PATCH 111/284] Add more contract guarantees

---
 .../SymbolTree/SymbolTreeInfo_Metadata.cs     |  4 +++-
 .../SymbolTreeInfo_Serialization.cs           | 23 +++----------------
 .../SymbolTree/SymbolTreeInfo_Source.cs       | 14 ++++++++---
 3 files changed, 17 insertions(+), 24 deletions(-)

diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
index 7ca0acbe92aba..3fa988e32885d 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
@@ -155,7 +155,7 @@ private static Task<SymbolTreeInfo> TryLoadOrCreateMetadataSymbolTreeInfoAsync(
         {
             var filePath = reference.FilePath;
 
-            return TryLoadOrCreateAsync(
+            var result = TryLoadOrCreateAsync(
                 solution,
                 checksum,
                 filePath,
@@ -165,6 +165,8 @@ private static Task<SymbolTreeInfo> TryLoadOrCreateMetadataSymbolTreeInfoAsync(
                 getPersistedChecksum: info => info.Checksum,
                 readObject: reader => ReadSymbolTreeInfo(reader, (names, nodes) => GetSpellCheckerTask(solution, checksum, filePath, names, nodes)),
                 cancellationToken: cancellationToken);
+            Contract.ThrowIfFalse(result != null || loadOnly == true, "Result can only be null if 'loadOnly: true' was passed.");
+            return result;
         }
 
         private static Task<SymbolTreeInfo> CreateMetadataSymbolTreeInfoAsync(
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
index 5d19ceb9081d7..cb1a23976f48c 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
@@ -19,25 +19,6 @@ internal partial class SymbolTreeInfo : IObjectWritable
         private const string PrefixMetadataSymbolTreeInfo = "<SymbolTreeInfo>";
         private const string SerializationFormat = "17";
 
-        /// <summary>
-        /// Loads the SymbolTreeInfo for a given assembly symbol (metadata or project).  If the
-        /// info can't be loaded, it will be created (and persisted if possible).
-        /// </summary>
-        private static Task<SymbolTreeInfo> LoadOrCreateSourceSymbolTreeInfoAsync(
-            Project project, Checksum checksum, bool loadOnly, CancellationToken cancellationToken)
-        {
-            return TryLoadOrCreateAsync(
-                project.Solution,
-                checksum,
-                project.FilePath,
-                loadOnly,
-                createAsync: () => CreateSourceSymbolTreeInfoAsync(project, checksum, cancellationToken),
-                keySuffix: "_Source",
-                getPersistedChecksum: info => info.Checksum,
-                readObject: reader => ReadSymbolTreeInfo(reader, (names, nodes) => GetSpellCheckerTask(project.Solution, checksum, project.FilePath, names, nodes)),
-                cancellationToken: cancellationToken);
-        }
-
         /// <summary>
         /// Loads the SpellChecker for a given assembly symbol (metadata or project).  If the
         /// info can't be loaded, it will be created (and persisted if possible).
@@ -48,7 +29,7 @@ private static Task<SpellChecker> LoadOrCreateSpellCheckerAsync(
             string filePath,
             Func<Task<SpellChecker>> createAsync)
         {
-            return TryLoadOrCreateAsync(
+            var result = TryLoadOrCreateAsync(
                 solution,
                 checksum,
                 filePath,
@@ -58,6 +39,8 @@ private static Task<SpellChecker> LoadOrCreateSpellCheckerAsync(
                 getPersistedChecksum: s => s.Checksum,
                 readObject: SpellChecker.ReadFrom,
                 cancellationToken: CancellationToken.None);
+            Contract.ThrowIfNull(result, "Result should never be null as we passed 'loadOnly: false'.");
+            return result;
         }
 
         /// <summary>
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
index 8c200861b3b2f..d8ca927426eac 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
@@ -29,9 +29,17 @@ private static void FreeSymbolMap(MultiDictionary<string, ISymbol> symbolMap)
         public static Task<SymbolTreeInfo> GetInfoForSourceAssemblyAsync(
             Project project, Checksum checksum, CancellationToken cancellationToken)
         {
-            var result = LoadOrCreateSourceSymbolTreeInfoAsync(
-                project, checksum, loadOnly: false, cancellationToken: cancellationToken);
-            Contract.ThrowIfNull(result);
+            var result = TryLoadOrCreateAsync(
+                project.Solution,
+                checksum,
+                project.FilePath,
+                loadOnly: false,
+                createAsync: () => CreateSourceSymbolTreeInfoAsync(project, checksum, cancellationToken),
+                keySuffix: "_Source",
+                getPersistedChecksum: info => info.Checksum,
+                readObject: reader => ReadSymbolTreeInfo(reader, (names, nodes) => GetSpellCheckerTask(project.Solution, checksum, project.FilePath, names, nodes)),
+                cancellationToken: cancellationToken);
+            Contract.ThrowIfNull(result, "Result should never be null as we passed 'loadOnly: false'.");
             return result;
         }
 

From 8b7ad834409d5c3434fb6aeea11e699ec3d7d96e Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 15:16:03 -0700
Subject: [PATCH 112/284] Don't require spell checker.

---
 .../FindSymbols/SymbolTree/SymbolTreeInfo.cs         |  4 ++--
 .../SymbolTree/SymbolTreeInfo_Metadata.cs            |  4 +---
 .../SymbolTree/SymbolTreeInfo_Serialization.cs       | 12 ++++--------
 .../FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs  |  4 +---
 .../Core/Portable/Utilities/SpellChecker.cs          |  2 +-
 5 files changed, 9 insertions(+), 17 deletions(-)

diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs
index e35d3329e8244..24ca8762d24cb 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs
@@ -16,9 +16,9 @@
 
 namespace Microsoft.CodeAnalysis.FindSymbols
 {
-    internal partial class SymbolTreeInfo
+    internal partial class SymbolTreeInfo : IChecksummedObject
     {
-        public readonly Checksum Checksum;
+        public Checksum Checksum { get; }
 
         /// <summary>
         /// To prevent lots of allocations, we concatenate all the names in all our
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
index 3fa988e32885d..9981c79f3940c 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
@@ -158,11 +158,9 @@ private static Task<SymbolTreeInfo> TryLoadOrCreateMetadataSymbolTreeInfoAsync(
             var result = TryLoadOrCreateAsync(
                 solution,
                 checksum,
-                filePath,
                 loadOnly,
                 createAsync: () => CreateMetadataSymbolTreeInfoAsync(solution, checksum, reference, cancellationToken),
-                keySuffix: "_Metadata",
-                getPersistedChecksum: info => info.Checksum,
+                keySuffix: "_Metadata_" + filePath,
                 readObject: reader => ReadSymbolTreeInfo(reader, (names, nodes) => GetSpellCheckerTask(solution, checksum, filePath, names, nodes)),
                 cancellationToken: cancellationToken);
             Contract.ThrowIfFalse(result != null || loadOnly == true, "Result can only be null if 'loadOnly: true' was passed.");
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
index cb1a23976f48c..f9787e62a75b1 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
@@ -32,11 +32,9 @@ private static Task<SpellChecker> LoadOrCreateSpellCheckerAsync(
             var result = TryLoadOrCreateAsync(
                 solution,
                 checksum,
-                filePath,
                 loadOnly: false,
                 createAsync: createAsync,
-                keySuffix: "_SpellChecker",
-                getPersistedChecksum: s => s.Checksum,
+                keySuffix: "_SpellChecker_" + filePath,
                 readObject: SpellChecker.ReadFrom,
                 cancellationToken: CancellationToken.None);
             Contract.ThrowIfNull(result, "Result should never be null as we passed 'loadOnly: false'.");
@@ -50,13 +48,11 @@ private static Task<SpellChecker> LoadOrCreateSpellCheckerAsync(
         private static async Task<T> TryLoadOrCreateAsync<T>(
             Solution solution,
             Checksum checksum,
-            string filePath,
             bool loadOnly,
             Func<Task<T>> createAsync,
             string keySuffix,
-            Func<T, Checksum> getPersistedChecksum,
             Func<ObjectReader, T> readObject,
-            CancellationToken cancellationToken) where T : class, IObjectWritable
+            CancellationToken cancellationToken) where T : class, IObjectWritable, IChecksummedObject
         {
             if (checksum == null) 
             {
@@ -70,7 +66,7 @@ private static async Task<T> TryLoadOrCreateAsync<T>(
             using (var storage = persistentStorageService.GetStorage(solution, checkBranchId: false))
             {
                 // Get the unique key to identify our data.
-                var key = PrefixMetadataSymbolTreeInfo + keySuffix + "_" + filePath;
+                var key = PrefixMetadataSymbolTreeInfo + keySuffix;
                 using (var stream = await storage.ReadStreamAsync(key, cancellationToken).ConfigureAwait(false))
                 using (var reader = ObjectReader.TryGetReader(stream))
                 {
@@ -80,7 +76,7 @@ private static async Task<T> TryLoadOrCreateAsync<T>(
                         // If we're able to, and the version of the persisted data matches
                         // our version, then we can reuse this instance.
                         result = readObject(reader);
-                        if (result != null && checksum == getPersistedChecksum(result))
+                        if (result != null && checksum == result.Checksum)
                         {
                             return result;
                         }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
index d8ca927426eac..05fd264c3a56c 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
@@ -32,11 +32,9 @@ public static Task<SymbolTreeInfo> GetInfoForSourceAssemblyAsync(
             var result = TryLoadOrCreateAsync(
                 project.Solution,
                 checksum,
-                project.FilePath,
                 loadOnly: false,
                 createAsync: () => CreateSourceSymbolTreeInfoAsync(project, checksum, cancellationToken),
-                keySuffix: "_Source",
-                getPersistedChecksum: info => info.Checksum,
+                keySuffix: "_Source_" + project.FilePath,
                 readObject: reader => ReadSymbolTreeInfo(reader, (names, nodes) => GetSpellCheckerTask(project.Solution, checksum, project.FilePath, names, nodes)),
                 cancellationToken: cancellationToken);
             Contract.ThrowIfNull(result, "Result should never be null as we passed 'loadOnly: false'.");
diff --git a/src/Workspaces/Core/Portable/Utilities/SpellChecker.cs b/src/Workspaces/Core/Portable/Utilities/SpellChecker.cs
index 31035b894eba2..a00ccf77c00a4 100644
--- a/src/Workspaces/Core/Portable/Utilities/SpellChecker.cs
+++ b/src/Workspaces/Core/Portable/Utilities/SpellChecker.cs
@@ -10,7 +10,7 @@
 
 namespace Roslyn.Utilities
 {
-    internal class SpellChecker : IObjectWritable
+    internal class SpellChecker : IObjectWritable, IChecksummedObject
     {
         private const string SerializationFormat = "3";
 

From c0adc6242fff999e0dc84d2aac1ee6d52ffaf2a3 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 15:19:15 -0700
Subject: [PATCH 113/284] Simplify code.

---
 .../Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs   | 4 ++--
 .../FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs   | 5 +++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs
index 24ca8762d24cb..c5d5d35e6ac54 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo.cs
@@ -331,8 +331,8 @@ private static Task<SpellChecker> GetSpellCheckerTask(
             // SymbolTreeInfo.  This way the SymbolTreeInfo will be ready immediately
             // for non-fuzzy searches, and soon afterwards it will be able to perform
             // fuzzy searches as well.
-            return Task.Run(() => LoadOrCreateSpellCheckerAsync(solution, checksum, filePath,
-                () => CreateSpellCheckerAsync(checksum, concatenatedNames, sortedNodes)));
+            return Task.Run(() => LoadOrCreateSpellCheckerAsync(
+                solution, checksum, filePath, concatenatedNames, sortedNodes));
         }
 
         private static Task<SpellChecker> CreateSpellCheckerAsync(Checksum checksum, string concatenatedNames, Node[] sortedNodes)
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
index f9787e62a75b1..3c26fec56c5ca 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
@@ -27,13 +27,14 @@ private static Task<SpellChecker> LoadOrCreateSpellCheckerAsync(
             Solution solution,
             Checksum checksum,
             string filePath,
-            Func<Task<SpellChecker>> createAsync)
+            string concatenatedNames,
+            Node[] sortedNodes)
         {
             var result = TryLoadOrCreateAsync(
                 solution,
                 checksum,
                 loadOnly: false,
-                createAsync: createAsync,
+                createAsync: () => CreateSpellCheckerAsync(checksum, concatenatedNames, sortedNodes),
                 keySuffix: "_SpellChecker_" + filePath,
                 readObject: SpellChecker.ReadFrom,
                 cancellationToken: CancellationToken.None);

From 51de32fb9afb742a3e6e9889a4f9ca78536969f0 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 15:38:55 -0700
Subject: [PATCH 114/284] Rename parameter.

---
 .../SymbolTree/SymbolTreeInfo_Metadata.cs            |  2 +-
 .../SymbolTree/SymbolTreeInfo_Serialization.cs       | 12 ++++++------
 .../FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs  |  2 +-
 .../Core/Portable/Utilities/SpellChecker.cs          |  2 +-
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
index 9981c79f3940c..20cac6563cfcc 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
@@ -161,7 +161,7 @@ private static Task<SymbolTreeInfo> TryLoadOrCreateMetadataSymbolTreeInfoAsync(
                 loadOnly,
                 createAsync: () => CreateMetadataSymbolTreeInfoAsync(solution, checksum, reference, cancellationToken),
                 keySuffix: "_Metadata_" + filePath,
-                readObject: reader => ReadSymbolTreeInfo(reader, (names, nodes) => GetSpellCheckerTask(solution, checksum, filePath, names, nodes)),
+                tryReadObject: reader => TryReadSymbolTreeInfo(reader, (names, nodes) => GetSpellCheckerTask(solution, checksum, filePath, names, nodes)),
                 cancellationToken: cancellationToken);
             Contract.ThrowIfFalse(result != null || loadOnly == true, "Result can only be null if 'loadOnly: true' was passed.");
             return result;
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
index 3c26fec56c5ca..b397e5ee967d1 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
@@ -36,7 +36,7 @@ private static Task<SpellChecker> LoadOrCreateSpellCheckerAsync(
                 loadOnly: false,
                 createAsync: () => CreateSpellCheckerAsync(checksum, concatenatedNames, sortedNodes),
                 keySuffix: "_SpellChecker_" + filePath,
-                readObject: SpellChecker.ReadFrom,
+                tryReadObject: SpellChecker.TryReadFrom,
                 cancellationToken: CancellationToken.None);
             Contract.ThrowIfNull(result, "Result should never be null as we passed 'loadOnly: false'.");
             return result;
@@ -52,7 +52,7 @@ private static async Task<T> TryLoadOrCreateAsync<T>(
             bool loadOnly,
             Func<Task<T>> createAsync,
             string keySuffix,
-            Func<ObjectReader, T> readObject,
+            Func<ObjectReader, T> tryReadObject,
             CancellationToken cancellationToken) where T : class, IObjectWritable, IChecksummedObject
         {
             if (checksum == null) 
@@ -76,8 +76,8 @@ private static async Task<T> TryLoadOrCreateAsync<T>(
                         // We have some previously persisted data.  Attempt to read it back.  
                         // If we're able to, and the version of the persisted data matches
                         // our version, then we can reuse this instance.
-                        result = readObject(reader);
-                        if (result != null && checksum == result.Checksum)
+                        result = tryReadObject(reader);
+                        if (result?.Checksum == result.Checksum)
                         {
                             return result;
                         }
@@ -142,12 +142,12 @@ public void WriteTo(ObjectWriter writer)
         internal static SymbolTreeInfo ReadSymbolTreeInfo_ForTestingPurposesOnly(
             ObjectReader reader, Checksum checksum)
         {
-            return ReadSymbolTreeInfo(reader, 
+            return TryReadSymbolTreeInfo(reader, 
                 (names, nodes) => Task.FromResult(
                     new SpellChecker(checksum, nodes.Select(n => new StringSlice(names, n.NameSpan)))));
         }
 
-        private static SymbolTreeInfo ReadSymbolTreeInfo(
+        private static SymbolTreeInfo TryReadSymbolTreeInfo(
             ObjectReader reader,
             Func<string, Node[], Task<SpellChecker>> createSpellCheckerTask)
         {
diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
index 05fd264c3a56c..002edd9d30c83 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Source.cs
@@ -35,7 +35,7 @@ public static Task<SymbolTreeInfo> GetInfoForSourceAssemblyAsync(
                 loadOnly: false,
                 createAsync: () => CreateSourceSymbolTreeInfoAsync(project, checksum, cancellationToken),
                 keySuffix: "_Source_" + project.FilePath,
-                readObject: reader => ReadSymbolTreeInfo(reader, (names, nodes) => GetSpellCheckerTask(project.Solution, checksum, project.FilePath, names, nodes)),
+                tryReadObject: reader => TryReadSymbolTreeInfo(reader, (names, nodes) => GetSpellCheckerTask(project.Solution, checksum, project.FilePath, names, nodes)),
                 cancellationToken: cancellationToken);
             Contract.ThrowIfNull(result, "Result should never be null as we passed 'loadOnly: false'.");
             return result;
diff --git a/src/Workspaces/Core/Portable/Utilities/SpellChecker.cs b/src/Workspaces/Core/Portable/Utilities/SpellChecker.cs
index a00ccf77c00a4..968174a7fdc42 100644
--- a/src/Workspaces/Core/Portable/Utilities/SpellChecker.cs
+++ b/src/Workspaces/Core/Portable/Utilities/SpellChecker.cs
@@ -49,7 +49,7 @@ void IObjectWritable.WriteTo(ObjectWriter writer)
             _bkTree.WriteTo(writer);
         }
 
-        internal static SpellChecker ReadFrom(ObjectReader reader)
+        internal static SpellChecker TryReadFrom(ObjectReader reader)
         {
             try
             {

From 4ddfe1fd78ef0badafe20d4e8e3f498dc3a678d2 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 15:39:22 -0700
Subject: [PATCH 115/284] Fix comparison.

---
 .../FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
index b397e5ee967d1..6ec42087d2908 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Serialization.cs
@@ -77,7 +77,7 @@ private static async Task<T> TryLoadOrCreateAsync<T>(
                         // If we're able to, and the version of the persisted data matches
                         // our version, then we can reuse this instance.
                         result = tryReadObject(reader);
-                        if (result?.Checksum == result.Checksum)
+                        if (result?.Checksum == checksum)
                         {
                             return result;
                         }

From 71c8e3e2cf575647e8573f1fe633ec3bfe139de6 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 17:29:34 -0700
Subject: [PATCH 116/284] Cache the delegates we use in simplification.

---
 ...ractCSharpReducer.AbstractExpressionRewriter.cs |  9 ---------
 .../Simplification/CSharpCastReducer.Rewriter.cs   |  2 +-
 .../Portable/Simplification/CSharpCastReducer.cs   |  5 ++++-
 .../CSharpEscapingReducer.Rewriter.cs              |  4 ++--
 .../Simplification/CSharpEscapingReducer.cs        |  7 +++++--
 .../CSharpExtensionMethodReducer.Rewriter.cs       |  4 ++--
 .../Simplification/CSharpExtensionMethodReducer.cs |  3 +++
 .../CSharpInferredMemberNameReducer.Rewriter.cs    |  4 ++--
 .../CSharpInferredMemberNameReducer.cs             |  4 ++++
 .../CSharpMiscellaneousReducer.Rewriter.cs         |  6 +++---
 .../Simplification/CSharpMiscellaneousReducer.cs   |  5 +++++
 .../Simplification/CSharpNameReducer.Rewriter.cs   | 14 +++++++-------
 .../Portable/Simplification/CSharpNameReducer.cs   |  3 +++
 .../CSharpParenthesesReducer.Rewriter.cs           |  4 ++--
 .../Simplification/CSharpParenthesesReducer.cs     |  5 ++++-
 .../Simplification/AbstractVisualBasicReducer.vb   |  5 +++--
 .../VisualBasicCallReducer.Rewriter.vb             |  7 +++----
 .../Simplification/VisualBasicCallReducer.vb       |  2 ++
 .../VisualBasicCastReducer.Rewriter.vb             | 11 +++++------
 .../Simplification/VisualBasicCastReducer.vb       |  8 ++++++--
 .../VisualBasicExtensionMethodReducer.Rewriter.vb  |  4 ++--
 .../VisualBasicExtensionMethodReducer.vb           |  2 ++
 ...isualBasicInferredMemberNameReducer.Rewriter.vb |  4 ++--
 .../VisualBasicInferredMemberNameReducer.vb        |  4 ++++
 .../VisualBasicMiscellaneousReducer.Rewriter.vb    |  9 ++++-----
 .../VisualBasicMiscellaneousReducer.vb             |  6 ++++++
 .../VisualBasicNameReducer.Rewriter.vb             | 12 ++++++------
 .../Simplification/VisualBasicNameReducer.vb       |  2 ++
 .../VisualBasicParenthesesReducer.Rewriter.vb      |  4 ++--
 ...isualBasicVariableDeclaratorReducer.Rewriter.vb |  2 +-
 .../VisualBasicVariableDeclaratorReducer.vb        |  2 ++
 31 files changed, 99 insertions(+), 64 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/Simplification/AbstractCSharpReducer.AbstractExpressionRewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/AbstractCSharpReducer.AbstractExpressionRewriter.cs
index 301e1ab1f4031..4b7745d97e5c2 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/AbstractCSharpReducer.AbstractExpressionRewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/AbstractCSharpReducer.AbstractExpressionRewriter.cs
@@ -128,15 +128,6 @@ protected SyntaxNode SimplifyExpression<TExpression>(
                 return SimplifyNode(expression, newNode, parentNode, simplifier);
             }
 
-            protected SyntaxNode SimplifyStatement<TStatement>(
-                TStatement statement,
-                SyntaxNode newNode,
-                Func<TStatement, SemanticModel, OptionSet, CancellationToken, SyntaxNode> simplifier)
-                where TStatement : ExpressionSyntax
-            {
-                return SimplifyNode(statement, newNode, GetParentNode(statement), simplifier);
-            }
-
             protected SyntaxToken SimplifyToken(SyntaxToken token, Func<SyntaxToken, SemanticModel, OptionSet, CancellationToken, SyntaxToken> simplifier)
             {
                 _cancellationToken.ThrowIfCancellationRequested();
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.Rewriter.cs
index decd0c467d6c8..61142fd6bb734 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.Rewriter.cs
@@ -22,7 +22,7 @@ public override SyntaxNode VisitCastExpression(CastExpressionSyntax node)
                 return SimplifyExpression(
                     node,
                     newNode: base.VisitCastExpression(node),
-                    simplifier: SimplifyCast);
+                    simplifier: s_simplifyCast);
             }
 
             public override SyntaxNode VisitBinaryExpression(BinaryExpressionSyntax node)
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.cs
index 2278227450219..09fb9da7ea087 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
@@ -17,6 +18,8 @@ public override IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet
             return new Rewriter(optionSet, cancellationToken);
         }
 
+        private static readonly Func<CastExpressionSyntax, SemanticModel, OptionSet, CancellationToken, ExpressionSyntax> s_simplifyCast = SimplifyCast;
+
         private static ExpressionSyntax SimplifyCast(CastExpressionSyntax node, SemanticModel semanticModel, OptionSet optionSet, CancellationToken cancellationToken)
         {
             if (!node.IsUnnecessaryCast(semanticModel, cancellationToken))
@@ -44,4 +47,4 @@ private static ExpressionSyntax SimplifyCast(CastExpressionSyntax node, Semantic
             return resultNode;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.Rewriter.cs
index 9006697fe7631..b4c07b6fd3750 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.Rewriter.cs
@@ -20,8 +20,8 @@ public Rewriter(CSharpEscapingReducer escapingSimplifierService, OptionSet optio
             public override SyntaxToken VisitToken(SyntaxToken token)
             {
                 var newToken = base.VisitToken(token);
-                return SimplifyToken(newToken, _escapingSimplifierService.SimplifyIdentifierToken);
+                return SimplifyToken(newToken, s_simplifyIdentifierToken);
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.cs
index 5cb68433eec07..b87d5a4b22cd9 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
@@ -17,7 +18,9 @@ public override IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet
             return new Rewriter(this, optionSet, cancellationToken);
         }
 
-        private SyntaxToken SimplifyIdentifierToken(
+        private static Func<SyntaxToken, SemanticModel, OptionSet, CancellationToken, SyntaxToken> s_simplifyIdentifierToken = SimplifyIdentifierToken;
+
+        private static SyntaxToken SimplifyIdentifierToken(
             SyntaxToken token,
             SemanticModel semanticModel,
             OptionSet optionSet,
@@ -114,7 +117,7 @@ private SyntaxToken SimplifyIdentifierToken(
             return result;
         }
 
-        private SyntaxToken CreateNewIdentifierTokenFromToken(SyntaxToken originalToken, bool escape)
+        private static SyntaxToken CreateNewIdentifierTokenFromToken(SyntaxToken originalToken, bool escape)
         {
             var isVerbatimIdentifier = originalToken.IsVerbatimIdentifier();
             if (isVerbatimIdentifier == escape)
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.Rewriter.cs
index 1f46ee17ee5f8..624e77dcee453 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.Rewriter.cs
@@ -20,8 +20,8 @@ public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax
                 return SimplifyExpression(
                     node,
                     newNode: base.VisitInvocationExpression(node),
-                    simplifier: SimplifyExtensionMethod);
+                    simplifier: s_simplifyExtensionMethod);
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.cs
index 28b2919a3da1b..15de394df2cf7 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Diagnostics;
 using System.Linq;
 using System.Threading;
@@ -17,6 +18,8 @@ public override IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet
             return new Rewriter(optionSet, cancellationToken);
         }
 
+        private static readonly Func<InvocationExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyExtensionMethod = SimplifyExtensionMethod;
+
         private static SyntaxNode SimplifyExtensionMethod(
             InvocationExpressionSyntax node,
             SemanticModel semanticModel,
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.Rewriter.cs
index f6a9aae9a8ca7..f19da855592f0 100755
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.Rewriter.cs
@@ -26,7 +26,7 @@ public override SyntaxNode VisitArgument(ArgumentSyntax node)
                         node,
                         parentNode: node.Parent,
                         newNode: newNode,
-                        simplifier: SimplifyTupleName);
+                        simplifier: s_simplifyTupleName);
                 }
 
                 return newNode;
@@ -38,7 +38,7 @@ public override SyntaxNode VisitAnonymousObjectMemberDeclarator(AnonymousObjectM
                     node,
                     parentNode: node.Parent,
                     newNode: base.VisitAnonymousObjectMemberDeclarator(node),
-                    simplifier: SimplifyAnonymousTypeMemberName);
+                    simplifier: s_simplifyAnonymousTypeMemberName);
             }
         }
     }
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.cs
index 21dc2d5051648..3983736cf0d41 100755
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -19,6 +20,8 @@ public override IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet
             return new Rewriter(optionSet, cancellationToken);
         }
 
+        private static readonly Func<ArgumentSyntax, SemanticModel, OptionSet, CancellationToken, ArgumentSyntax> s_simplifyTupleName = SimplifyTupleName;
+
         private static ArgumentSyntax SimplifyTupleName(ArgumentSyntax node, SemanticModel semanticModel, OptionSet optionSet, CancellationToken cancellationToken)
         {
             // Tuple elements are arguments in a tuple expression
@@ -37,6 +40,7 @@ private static ArgumentSyntax SimplifyTupleName(ArgumentSyntax node, SemanticMod
             return node.WithNameColon(null).WithTriviaFrom(node);
         }
 
+        private static readonly Func<AnonymousObjectMemberDeclaratorSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyAnonymousTypeMemberName = SimplifyAnonymousTypeMemberName;
 
         private static SyntaxNode SimplifyAnonymousTypeMemberName(AnonymousObjectMemberDeclaratorSyntax node, SemanticModel semanticModel, OptionSet optionSet, CancellationToken canellationToken)
         {
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.Rewriter.cs
index 4ac9b91e11c28..c338efd9e1ccd 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.Rewriter.cs
@@ -21,7 +21,7 @@ public override SyntaxNode VisitParameter(ParameterSyntax node)
                     node,
                     newNode: base.VisitParameter(node),
                     parentNode: node.Parent,
-                    simplifier: SimplifyParameter);
+                    simplifier: s_simplifyParameter);
             }
 
             public override SyntaxNode VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node)
@@ -30,8 +30,8 @@ public override SyntaxNode VisitParenthesizedLambdaExpression(ParenthesizedLambd
                     node,
                     newNode: base.VisitParenthesizedLambdaExpression(node),
                     parentNode: node.Parent,
-                    simplifier: SimplifyParenthesizedLambdaExpression);
+                    simplifier: s_simplifyParenthesizedLambdaExpression);
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.cs
index 33ccbe2bf2b23..4d3c315c30b31 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
@@ -50,6 +51,8 @@ private static bool CanRemoveTypeFromParameter(
             return false;
         }
 
+        private static Func<SyntaxNode, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyParameter = SimplifyParameter;
+
         private static SyntaxNode SimplifyParameter(
             SyntaxNode node,
             SemanticModel semanticModel,
@@ -66,6 +69,8 @@ private static SyntaxNode SimplifyParameter(
             return node;
         }
 
+        private static readonly Func<SyntaxNode, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyParenthesizedLambdaExpression = SimplifyParenthesizedLambdaExpression;
+
         private static SyntaxNode SimplifyParenthesizedLambdaExpression(
             SyntaxNode node,
             SemanticModel semanticModel,
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.Rewriter.cs
index 6a98638a369c3..87e19ddd40d73 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.Rewriter.cs
@@ -30,7 +30,7 @@ public override SyntaxNode VisitPredefinedType(PredefinedTypeSyntax node)
                 var result = SimplifyExpression(
                     node,
                     newNode: base.VisitPredefinedType(node),
-                    simplifier: SimplifyName);
+                    simplifier: s_simplifyName);
 
                 this.alwaysSimplify = oldAlwaysSimplify;
 
@@ -48,7 +48,7 @@ public override SyntaxNode VisitAliasQualifiedName(AliasQualifiedNameSyntax node
                 var result = SimplifyExpression(
                     node,
                     newNode: base.VisitAliasQualifiedName(node),
-                    simplifier: SimplifyName);
+                    simplifier: s_simplifyName);
 
                 this.alwaysSimplify = oldAlwaysSimplify;
 
@@ -66,7 +66,7 @@ public override SyntaxNode VisitQualifiedName(QualifiedNameSyntax node)
                 var result = SimplifyExpression(
                     node,
                     newNode: base.VisitQualifiedName(node),
-                    simplifier: SimplifyName);
+                    simplifier: s_simplifyName);
 
                 this.alwaysSimplify = oldAlwaysSimplify;
 
@@ -84,7 +84,7 @@ public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyn
                 var result = SimplifyExpression(
                     node,
                     newNode: base.VisitMemberAccessExpression(node),
-                    simplifier: SimplifyName);
+                    simplifier: s_simplifyName);
 
                 this.alwaysSimplify = oldAlwaysSimplify;
 
@@ -102,7 +102,7 @@ public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node)
                 var result = SimplifyExpression(
                     node,
                     newNode: base.VisitIdentifierName(node),
-                    simplifier: SimplifyName);
+                    simplifier: s_simplifyName);
 
                 this.alwaysSimplify = oldAlwaysSimplify;
 
@@ -120,7 +120,7 @@ public override SyntaxNode VisitGenericName(GenericNameSyntax node)
                 var result = SimplifyExpression(
                     node,
                     newNode: base.VisitGenericName(node),
-                    simplifier: SimplifyName);
+                    simplifier: s_simplifyName);
 
                 this.alwaysSimplify = oldAlwaysSimplify;
 
@@ -138,7 +138,7 @@ public override SyntaxNode VisitQualifiedCref(QualifiedCrefSyntax node)
                 var result = SimplifyExpression(
                     node,
                     newNode: base.VisitQualifiedCref(node),
-                    simplifier: SimplifyName);
+                    simplifier: s_simplifyName);
 
                 this.alwaysSimplify = oldAlwaysSimplify;
 
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.cs
index 28b1974ff6e06..d9bc79dfeea30 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -17,6 +18,8 @@ public override IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet
             return new Rewriter(optionSet, cancellationToken);
         }
 
+        private static readonly Func<SyntaxNode, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyName = SimplifyName;
+
         private static SyntaxNode SimplifyName(
             SyntaxNode node,
             SemanticModel semanticModel,
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.Rewriter.cs
index d0f4124e6f49d..c20a0b1c4c015 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.Rewriter.cs
@@ -20,8 +20,8 @@ public override SyntaxNode VisitParenthesizedExpression(ParenthesizedExpressionS
                 return SimplifyExpression(
                     node,
                     newNode: base.VisitParenthesizedExpression(node),
-                    simplifier: SimplifyParentheses);
+                    simplifier: s_simplifyParentheses);
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.cs
index cc14cf1eb4227..1e525ed1fe5e1 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
@@ -17,6 +18,8 @@ public override IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet
             return new Rewriter(optionSet, cancellationToken);
         }
 
+        private static readonly Func<ParenthesizedExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyParentheses = SimplifyParentheses;
+
         private static SyntaxNode SimplifyParentheses(
             ParenthesizedExpressionSyntax node,
             SemanticModel semanticModel,
@@ -54,4 +57,4 @@ private static SyntaxNode SimplifyParentheses(
             return node;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/AbstractVisualBasicReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/AbstractVisualBasicReducer.vb
index 38e7bae8fd0b1..0212ce261c265 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/AbstractVisualBasicReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/AbstractVisualBasicReducer.vb
@@ -9,6 +9,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend MustInherit Class AbstractVisualBasicReducer
         Inherits AbstractReducer
 
+        Protected Shared ReadOnly s_reduceParentheses As Func(Of ParenthesizedExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf ReduceParentheses
+
         Protected Shared Function ReduceParentheses(
             node As ParenthesizedExpressionSyntax,
             semanticModel As SemanticModel,
@@ -45,6 +47,5 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             ' We don't know how to simplify this.
             Return node
         End Function
-
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.Rewriter.vb
index 42a058bd30f3f..5b1aef9915c0d 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.Rewriter.vb
@@ -17,16 +17,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 Return SimplifyStatement(
                     node,
                     newNode:=MyBase.VisitCallStatement(node),
-                    simplifier:=AddressOf SimplifyCallStatement)
+                    simplifier:=s_simplifyCallStatement)
             End Function
 
             Public Overrides Function VisitParenthesizedExpression(node As ParenthesizedExpressionSyntax) As SyntaxNode
                 Return SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitParenthesizedExpression(node),
-                    simplifier:=AddressOf ReduceParentheses)
+                    simplifier:=s_reduceParentheses)
             End Function
-
         End Class
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.vb
index 6db8e03ebf950..3f8be8e1277f0 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.vb
@@ -13,6 +13,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return New Rewriter(optionSet, cancellationToken)
         End Function
 
+        Private Shared ReadOnly s_simplifyCallStatement As Func(Of CallStatementSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyCallStatement
+
         Private Shared Function SimplifyCallStatement(
             callStatement As CallStatementSyntax,
             semanticModel As SemanticModel,
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.Rewriter.vb
index 86759bb92efd2..cd876badbc161 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.Rewriter.vb
@@ -17,30 +17,29 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 Return SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitCTypeExpression(node),
-                    simplifier:=AddressOf SimplifyCast)
+                    simplifier:=s_simplifyCast)
             End Function
 
             Public Overrides Function VisitDirectCastExpression(node As DirectCastExpressionSyntax) As SyntaxNode
                 Return SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitDirectCastExpression(node),
-                    simplifier:=AddressOf SimplifyCast)
+                    simplifier:=s_simplifyCast)
             End Function
 
             Public Overrides Function VisitTryCastExpression(node As TryCastExpressionSyntax) As SyntaxNode
                 Return SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitTryCastExpression(node),
-                    simplifier:=AddressOf SimplifyCast)
+                    simplifier:=s_simplifyCast)
             End Function
 
             Public Overrides Function VisitPredefinedCastExpression(node As PredefinedCastExpressionSyntax) As SyntaxNode
                 Return SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitPredefinedCastExpression(node),
-                    simplifier:=AddressOf SimplifyCast)
+                    simplifier:=s_simplifyPredefinedCast)
             End Function
-
         End Class
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.vb
index f0a09e91223ad..5b968bf017042 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.vb
@@ -29,6 +29,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return resultNode
         End Function
 
+        Private Shared ReadOnly s_simplifyCast As Func(Of CastExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = s_simplifyCast
+
         Private Overloads Shared Function SimplifyCast(
             node As CastExpressionSyntax,
             semanticModel As SemanticModel,
@@ -43,7 +45,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return SimplifyCast(node, node.Expression, optionSet, cancellationToken)
         End Function
 
-        Private Overloads Shared Function SimplifyCast(
+        Private Shared ReadOnly s_simplifyPredefinedCast As Func(Of PredefinedCastExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyPredefinedCast
+
+        Private Overloads Shared Function SimplifyPredefinedCast(
             node As PredefinedCastExpressionSyntax,
             semanticModel As SemanticModel,
             optionSet As OptionSet,
@@ -57,4 +61,4 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return SimplifyCast(node, node.Expression, optionSet, cancellationToken)
         End Function
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.Rewriter.vb
index 051af71841f0d..7c82c5718df76 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.Rewriter.vb
@@ -19,8 +19,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 Return SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitInvocationExpression(node),
-                    simplifier:=AddressOf SimplifyInvocationExpression)
+                    simplifier:=s_simplifyInvocationExpression)
             End Function
         End Class
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.vb
index 0dcc233ea25ae..4117cc5c82c1a 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.vb
@@ -12,6 +12,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return New Rewriter(optionSet, cancellationToken)
         End Function
 
+        Private Shared ReadOnly s_simplifyInvocationExpression As Func(Of InvocationExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyInvocationExpression
+
         Private Shared Function SimplifyInvocationExpression(
             invocationExpression As InvocationExpressionSyntax,
             semanticModel As SemanticModel,
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.Rewriter.vb
index 47d16bdfbb964..84b9c68f0ee09 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.Rewriter.vb
@@ -24,7 +24,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                         node,
                         parentNode:=node.Parent,
                         newNode:=newNode,
-                        simplifyFunc:=AddressOf SimplifyTupleName)
+                        simplifyFunc:=s_simplifyTupleName)
                 End If
 
                 Return newNode
@@ -37,7 +37,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                     node,
                     parentNode:=node.Parent,
                     newNode:=newNode,
-                    simplifyFunc:=AddressOf SimplifyNamedFieldInitializer)
+                    simplifyFunc:=s_simplifyNamedFieldInitializer)
             End Function
         End Class
     End Class
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.vb
index b3e14d8dd7613..97f1ff8b4ccf5 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.vb
@@ -18,6 +18,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return New VisualBasicInferredMemberNameReducer.Rewriter(optionSet, cancellationToken)
         End Function
 
+        Private Shared ReadOnly s_simplifyTupleName As Func(Of SimpleArgumentSyntax, SemanticModel, OptionSet, CancellationToken, SimpleArgumentSyntax) = AddressOf SimplifyTupleName
+
         Private Shared Function SimplifyTupleName(
             node As SimpleArgumentSyntax,
             semanticModel As SemanticModel,
@@ -41,6 +43,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return node.WithNameColonEquals(Nothing).WithTriviaFrom(node)
         End Function
 
+        Private Shared ReadOnly s_simplifyNamedFieldInitializer As Func(Of NamedFieldInitializerSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyNamedFieldInitializer
+
         Private Shared Function SimplifyNamedFieldInitializer(node As NamedFieldInitializerSyntax, arg2 As SemanticModel, arg3 As OptionSet, arg4 As CancellationToken) As SyntaxNode
             Dim inferredName = node.Expression.TryGetInferredMemberName()
 
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.Rewriter.vb
index 178e52712c088..05ae22615b503 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.Rewriter.vb
@@ -19,7 +19,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 Return SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitInvocationExpression(node),
-                    simplifier:=AddressOf SimplifyInvocationExpression)
+                    simplifier:=s_simplifyInvocationExpression)
             End Function
 
             Public Overrides Function VisitObjectCreationExpression(node As ObjectCreationExpressionSyntax) As SyntaxNode
@@ -28,7 +28,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 Return SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitObjectCreationExpression(node),
-                    simplifier:=AddressOf SimplifyObjectCreationExpression)
+                    simplifier:=s_simplifyObjectCreationExpression)
             End Function
 
             Public Overrides Function VisitParameter(node As ParameterSyntax) As SyntaxNode
@@ -38,9 +38,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                     node,
                     newNode:=MyBase.VisitParameter(node),
                     parentNode:=node.Parent,
-                    simplifyFunc:=AddressOf SimplifyParameter)
+                    simplifyFunc:=s_simplifyParameter)
             End Function
-
         End Class
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.vb
index 864d6d1341aad..4589357439bd1 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.vb
@@ -13,6 +13,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return New Rewriter(optionSet, cancellationToken)
         End Function
 
+        Private Shared ReadOnly s_simplifyParameter As Func(Of ParameterSyntax, SemanticModel, OptionSet, CancellationToken, ParameterSyntax) = AddressOf SimplifyParameter
+
         Private Shared Function SimplifyParameter(
             parameter As ParameterSyntax,
             semanticModel As SemanticModel,
@@ -28,6 +30,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return parameter
         End Function
 
+        Private Shared ReadOnly s_simplifyInvocationExpression As Func(Of InvocationExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyInvocationExpression
+
         Private Shared Function SimplifyInvocationExpression(
             invocationExpression As InvocationExpressionSyntax,
             semanticModel As SemanticModel,
@@ -49,6 +53,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return invocationExpression
         End Function
 
+        Private Shared ReadOnly s_simplifyObjectCreationExpression As Func(Of ObjectCreationExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyObjectCreationExpression
+
         Private Shared Function SimplifyObjectCreationExpression(
             objectCreationExpression As ObjectCreationExpressionSyntax,
             semanticModel As SemanticModel,
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.Rewriter.vb
index 87fc446f4a74c..0e6d8abba873b 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.Rewriter.vb
@@ -23,7 +23,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 Dim result = SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitGenericName(node),
-                    simplifier:=AddressOf SimplifyName)
+                    simplifier:=s_simplifyName)
 
                 Me._alwaysSimplify = oldAlwaysSimplify
 
@@ -39,7 +39,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 Dim result = SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitIdentifierName(node),
-                    simplifier:=AddressOf SimplifyName)
+                    simplifier:=s_simplifyName)
 
                 Me._alwaysSimplify = oldAlwaysSimplify
 
@@ -55,7 +55,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 Dim result = SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitQualifiedName(node),
-                    simplifier:=AddressOf SimplifyName)
+                    simplifier:=s_simplifyName)
 
                 Me._alwaysSimplify = oldAlwaysSimplify
 
@@ -71,7 +71,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 Dim result = SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitMemberAccessExpression(node),
-                    simplifier:=AddressOf SimplifyName)
+                    simplifier:=s_simplifyName)
 
                 Me._alwaysSimplify = oldAlwaysSimplify
 
@@ -87,7 +87,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 Dim result = SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitNullableType(node),
-                    simplifier:=AddressOf SimplifyName)
+                    simplifier:=s_simplifyName)
 
                 Me._alwaysSimplify = oldAlwaysSimplify
 
@@ -103,7 +103,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 Dim result = SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitArrayType(node),
-                    simplifier:=AddressOf SimplifyName)
+                    simplifier:=s_simplifyName)
 
                 Me._alwaysSimplify = oldAlwaysSimplify
 
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.vb
index 56163216a1e79..c31bb23a9e74e 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.vb
@@ -16,6 +16,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return New Rewriter(optionSet, cancellationToken)
         End Function
 
+        Private Shared ReadOnly s_simplifyName As Func(Of ExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyName
+
         Private Overloads Shared Function SimplifyName(
             node As ExpressionSyntax,
             semanticModel As SemanticModel,
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicParenthesesReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicParenthesesReducer.Rewriter.vb
index 74ccb04635703..7766e4a29ba78 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicParenthesesReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicParenthesesReducer.Rewriter.vb
@@ -17,8 +17,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 Return SimplifyExpression(
                     node,
                     newNode:=MyBase.VisitParenthesizedExpression(node),
-                    simplifier:=AddressOf ReduceParentheses)
+                    simplifier:=s_reduceParentheses)
             End Function
         End Class
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.Rewriter.vb
index e8a14a2feaea7..3236a101873a0 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.Rewriter.vb
@@ -19,7 +19,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                     node,
                     newNode:=MyBase.VisitVariableDeclarator(node),
                     parentNode:=node,
-                    simplifyFunc:=AddressOf SimplifyVariableDeclarator)
+                    simplifyFunc:=s_simplifyVariableDeclarator)
             End Function
         End Class
     End Class
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.vb
index 997bc0a110574..a9204fae01301 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.vb
@@ -15,6 +15,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return New Rewriter(optionSet, cancellationToken)
         End Function
 
+        Private Shared ReadOnly s_simplifyVariableDeclarator As Func(Of VariableDeclaratorSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyVariableDeclarator
+
         Private Overloads Shared Function SimplifyVariableDeclarator(
             node As VariableDeclaratorSyntax,
             semanticModel As SemanticModel,

From 8e4e29b08d6608fecd2f415f1abec66e71689764 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 18:47:30 -0700
Subject: [PATCH 117/284] Pool the simplifiers we create while simplifying
 code.

---
 .../CSharp/Portable/CSharpWorkspace.csproj    |  32 ++--
 .../CodeGeneration/CSharpSyntaxGenerator.cs   |   4 +-
 ...SharpReducer.AbstractReductionRewriter.cs} |  41 +++--
 .../{ => Reducers}/AbstractCSharpReducer.cs   |   6 +-
 .../CSharpCastReducer.Rewriter.cs             |  11 +-
 .../{ => Reducers}/CSharpCastReducer.cs       |   7 +-
 .../CSharpEscapingReducer.Rewriter.cs         |  12 +-
 .../{ => Reducers}/CSharpEscapingReducer.cs   |   9 +-
 .../CSharpExtensionMethodReducer.Rewriter.cs  |   9 +-
 .../CSharpExtensionMethodReducer.cs           |  15 +-
 ...SharpInferredMemberNameReducer.Rewriter.cs |  12 +-
 .../CSharpInferredMemberNameReducer.cs        |   9 +-
 .../CSharpMiscellaneousReducer.Rewriter.cs    |   9 +-
 .../CSharpMiscellaneousReducer.cs             |   9 +-
 .../CSharpNameReducer.Rewriter.cs             |  12 +-
 .../{ => Reducers}/CSharpNameReducer.cs       |   9 +-
 .../CSharpParenthesesReducer.Rewriter.cs      |   9 +-
 .../CSharpParenthesesReducer.cs               |   7 +-
 .../AbstractReducer.IExpressionRewriter.cs    |  10 +-
 .../Simplification/AbstractReducer.cs         |  13 +-
 .../AbstractSimplificationService.cs          | 143 +++++++++---------
 .../Portable/BasicWorkspace.vbproj            |  40 ++---
 ...BasicReducer.AbstractReductionRewriter.vb} |  48 ++++--
 .../AbstractVisualBasicReducer.vb             |   4 +
 .../VisualBasicCallReducer.Rewriter.vb        |   8 +-
 .../{ => Reducers}/VisualBasicCallReducer.vb  |  12 +-
 .../VisualBasicCastReducer.Rewriter.vb        |   8 +-
 .../{ => Reducers}/VisualBasicCastReducer.vb  |   9 +-
 .../VisualBasicEscapingReducer.Rewriter.vb    |  10 +-
 .../VisualBasicEscapingReducer.vb             |  13 +-
 ...ualBasicExtensionMethodReducer.Rewriter.vb |   7 +-
 .../VisualBasicExtensionMethodReducer.vb      |  12 +-
 ...BasicInferredMemberNameReducer.Rewriter.vb |   9 +-
 .../VisualBasicInferredMemberNameReducer.vb   |  11 +-
 ...isualBasicMiscellaneousReducer.Rewriter.vb |   7 +-
 .../VisualBasicMiscellaneousReducer.vb        |  12 +-
 .../VisualBasicNameReducer.Rewriter.vb        |  11 +-
 .../{ => Reducers}/VisualBasicNameReducer.vb  |  12 +-
 .../VisualBasicParenthesesReducer.Rewriter.vb |   8 +-
 .../VisualBasicParenthesesReducer.vb          |  13 +-
 ...BasicVariableDeclaratorReducer.Rewriter.vb |  11 +-
 .../VisualBasicVariableDeclaratorReducer.vb   |  12 +-
 42 files changed, 364 insertions(+), 301 deletions(-)
 rename src/Workspaces/CSharp/Portable/Simplification/{AbstractCSharpReducer.AbstractExpressionRewriter.cs => Reducers/AbstractCSharpReducer.AbstractReductionRewriter.cs} (86%)
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/AbstractCSharpReducer.cs (72%)
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpCastReducer.Rewriter.cs (92%)
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpCastReducer.cs (89%)
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpEscapingReducer.Rewriter.cs (54%)
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpEscapingReducer.cs (96%)
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpExtensionMethodReducer.Rewriter.cs (73%)
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpExtensionMethodReducer.cs (94%)
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpInferredMemberNameReducer.Rewriter.cs (82%)
 mode change 100755 => 100644
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpInferredMemberNameReducer.cs (91%)
 mode change 100755 => 100644
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpMiscellaneousReducer.Rewriter.cs (80%)
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpMiscellaneousReducer.cs (95%)
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpNameReducer.Rewriter.cs (95%)
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpNameReducer.cs (90%)
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpParenthesesReducer.Rewriter.cs (73%)
 rename src/Workspaces/CSharp/Portable/Simplification/{ => Reducers}/CSharpParenthesesReducer.cs (91%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{AbstractVisualBasicSimplifier.AbstractExpressionRewriter.vb => Reducers/AbstractVisualBasicReducer.AbstractReductionRewriter.vb} (86%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/AbstractVisualBasicReducer.vb (95%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicCallReducer.Rewriter.vb (80%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicCallReducer.vb (85%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicCastReducer.Rewriter.vb (86%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicCastReducer.vb (91%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicEscapingReducer.Rewriter.vb (74%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicEscapingReducer.vb (96%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicExtensionMethodReducer.Rewriter.vb (78%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicExtensionMethodReducer.vb (93%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicInferredMemberNameReducer.Rewriter.vb (85%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicInferredMemberNameReducer.vb (90%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicMiscellaneousReducer.Rewriter.vb (87%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicMiscellaneousReducer.vb (93%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicNameReducer.Rewriter.vb (93%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicNameReducer.vb (87%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicParenthesesReducer.Rewriter.vb (74%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicParenthesesReducer.vb (52%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicVariableDeclaratorReducer.Rewriter.vb (71%)
 rename src/Workspaces/VisualBasic/Portable/Simplification/{ => Reducers}/VisualBasicVariableDeclaratorReducer.vb (86%)

diff --git a/src/Workspaces/CSharp/Portable/CSharpWorkspace.csproj b/src/Workspaces/CSharp/Portable/CSharpWorkspace.csproj
index 2e41f200b1739..1edfa6cb05691 100644
--- a/src/Workspaces/CSharp/Portable/CSharpWorkspace.csproj
+++ b/src/Workspaces/CSharp/Portable/CSharpWorkspace.csproj
@@ -209,22 +209,22 @@
     <Compile Include="Rename\CSharpRenameRewriterLanguageService.cs" />
     <Compile Include="Rename\LabelConflictVisitor.cs" />
     <Compile Include="Rename\LocalConflictVisitor.cs" />
-    <Compile Include="Simplification\AbstractCSharpReducer.AbstractExpressionRewriter.cs" />
-    <Compile Include="Simplification\AbstractCSharpReducer.cs" />
-    <Compile Include="Simplification\CSharpCastReducer.cs" />
-    <Compile Include="Simplification\CSharpInferredMemberNameReducer.cs" />
-    <Compile Include="Simplification\CSharpInferredMemberNameReducer.Rewriter.cs" />
-    <Compile Include="Simplification\CSharpCastReducer.Rewriter.cs" />
-    <Compile Include="Simplification\CSharpEscapingReducer.cs" />
-    <Compile Include="Simplification\CSharpEscapingReducer.Rewriter.cs" />
-    <Compile Include="Simplification\CSharpExtensionMethodReducer.cs" />
-    <Compile Include="Simplification\CSharpExtensionMethodReducer.Rewriter.cs" />
-    <Compile Include="Simplification\CSharpMiscellaneousReducer.cs" />
-    <Compile Include="Simplification\CSharpMiscellaneousReducer.Rewriter.cs" />
-    <Compile Include="Simplification\CSharpNameReducer.cs" />
-    <Compile Include="Simplification\CSharpNameReducer.Rewriter.cs" />
-    <Compile Include="Simplification\CSharpParenthesesReducer.cs" />
-    <Compile Include="Simplification\CSharpParenthesesReducer.Rewriter.cs" />
+    <Compile Include="Simplification\Reducers\AbstractCSharpReducer.AbstractReductionRewriter.cs" />
+    <Compile Include="Simplification\Reducers\AbstractCSharpReducer.cs" />
+    <Compile Include="Simplification\Reducers\CSharpCastReducer.cs" />
+    <Compile Include="Simplification\Reducers\CSharpInferredMemberNameReducer.cs" />
+    <Compile Include="Simplification\Reducers\CSharpInferredMemberNameReducer.Rewriter.cs" />
+    <Compile Include="Simplification\Reducers\CSharpCastReducer.Rewriter.cs" />
+    <Compile Include="Simplification\Reducers\CSharpEscapingReducer.cs" />
+    <Compile Include="Simplification\Reducers\CSharpEscapingReducer.Rewriter.cs" />
+    <Compile Include="Simplification\Reducers\CSharpExtensionMethodReducer.cs" />
+    <Compile Include="Simplification\Reducers\CSharpExtensionMethodReducer.Rewriter.cs" />
+    <Compile Include="Simplification\Reducers\CSharpMiscellaneousReducer.cs" />
+    <Compile Include="Simplification\Reducers\CSharpMiscellaneousReducer.Rewriter.cs" />
+    <Compile Include="Simplification\Reducers\CSharpNameReducer.cs" />
+    <Compile Include="Simplification\Reducers\CSharpNameReducer.Rewriter.cs" />
+    <Compile Include="Simplification\Reducers\CSharpParenthesesReducer.cs" />
+    <Compile Include="Simplification\Reducers\CSharpParenthesesReducer.Rewriter.cs" />
     <Compile Include="Simplification\CSharpSimplificationService.cs" />
     <Compile Include="Simplification\CSharpSimplificationService.Expander.cs" />
     <Compile Include="Simplification\CSharpSimplificationService.NodesAndTokensToReduceComputer.cs" />
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
index c85c224bc1b65..276ac06c8ff00 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
@@ -3524,9 +3524,7 @@ public override SyntaxNode IfStatement(SyntaxNode condition, IEnumerable<SyntaxN
         }
 
         private BlockSyntax CreateBlock(IEnumerable<SyntaxNode> statements)
-        {
-            return SyntaxFactory.Block(AsStatementList(statements));
-        }
+            => SyntaxFactory.Block(AsStatementList(statements)).WithAdditionalAnnotations(Simplifier.Annotation);
 
         private SyntaxList<StatementSyntax> AsStatementList(IEnumerable<SyntaxNode> nodes)
         {
diff --git a/src/Workspaces/CSharp/Portable/Simplification/AbstractCSharpReducer.AbstractExpressionRewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.AbstractReductionRewriter.cs
similarity index 86%
rename from src/Workspaces/CSharp/Portable/Simplification/AbstractCSharpReducer.AbstractExpressionRewriter.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.AbstractReductionRewriter.cs
index 4b7745d97e5c2..48bc70d426c05 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/AbstractCSharpReducer.AbstractExpressionRewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.AbstractReductionRewriter.cs
@@ -5,34 +5,51 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Threading;
-using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Simplification;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal abstract partial class AbstractCSharpReducer
     {
-        protected abstract class AbstractExpressionRewriter : CSharpSyntaxRewriter, IExpressionRewriter
+        protected abstract class AbstractReductionRewriter : CSharpSyntaxRewriter, IReductionRewriter
         {
-            private readonly OptionSet _optionSet;
-            private readonly CancellationToken _cancellationToken;
-            private readonly HashSet<SyntaxNode> _processedParentNodes;
+            private readonly ObjectPool<IReductionRewriter> _pool;
+
+            private OptionSet _optionSet;
+            private CancellationToken _cancellationToken;
             private SemanticModel _semanticModel;
 
-            protected AbstractExpressionRewriter(OptionSet optionSet, CancellationToken cancellationToken)
+            public bool HasMoreWork { get; private set; }
+
+            // can be used to simplify whole subtrees while just annotating one syntax node.
+            // This is e.g. useful in the name simplification, where a whole qualified name is annotated
+            protected bool alwaysSimplify;
+
+            private HashSet<SyntaxNode> _processedParentNodes = new HashSet<SyntaxNode>();
+
+            protected AbstractReductionRewriter(ObjectPool<IReductionRewriter> pool)
+                => _pool = pool;
+
+            public void Initialize(OptionSet optionSet, CancellationToken cancellationToken)
             {
                 _optionSet = optionSet;
                 _cancellationToken = cancellationToken;
-                _processedParentNodes = new HashSet<SyntaxNode>();
             }
 
-            public bool HasMoreWork { get; private set; }
+            public void Dispose()
+            {
+                _optionSet = null;
+                _cancellationToken = CancellationToken.None;
+                _processedParentNodes.Clear();
+                _semanticModel = null;
+                HasMoreWork = false;
+                alwaysSimplify = false;
 
-            // can be used to simplify whole subtrees while just annotating one syntax node.
-            // This is e.g. useful in the name simplification, where a whole qualified name is annotated
-            protected bool alwaysSimplify;
+                _pool.Free(this);
+            }
 
             private static SyntaxNode GetParentNode(SyntaxNode node)
             {
@@ -173,4 +190,4 @@ public SyntaxNodeOrToken VisitNodeOrToken(SyntaxNodeOrToken nodeOrToken, Semanti
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/AbstractCSharpReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.cs
similarity index 72%
rename from src/Workspaces/CSharp/Portable/Simplification/AbstractCSharpReducer.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.cs
index 276840f49798b..c58f9b875fa78 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/AbstractCSharpReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.cs
@@ -1,10 +1,14 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using Microsoft.CodeAnalysis.Simplification;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal abstract partial class AbstractCSharpReducer : AbstractReducer
     {
+        protected AbstractCSharpReducer(ObjectPool<IReductionRewriter> pool) : base(pool)
+        {
+        }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpCastReducer.Rewriter.cs
similarity index 92%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.Rewriter.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpCastReducer.Rewriter.cs
index 61142fd6bb734..ceecc0991547c 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpCastReducer.Rewriter.cs
@@ -1,19 +1,18 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Linq;
-using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Simplification;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal partial class CSharpCastReducer
     {
-        private class Rewriter : AbstractExpressionRewriter
+        private class Rewriter : AbstractReductionRewriter
         {
-            public Rewriter(OptionSet optionSet, CancellationToken cancellationToken)
-                : base(optionSet, cancellationToken)
+            public Rewriter(ObjectPool<IReductionRewriter> pool)
+                : base(pool)
             {
             }
 
@@ -69,4 +68,4 @@ public override SyntaxNode VisitBinaryExpression(BinaryExpressionSyntax node)
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpCastReducer.cs
similarity index 89%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpCastReducer.cs
index 09fb9da7ea087..848328cac71d2 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpCastReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpCastReducer.cs
@@ -8,14 +8,17 @@
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Simplification;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal partial class CSharpCastReducer : AbstractCSharpReducer
     {
-        public override IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet, CancellationToken cancellationToken)
+        private static readonly ObjectPool<IReductionRewriter> s_pool = new ObjectPool<IReductionRewriter>(
+            () => new Rewriter(s_pool));
+
+        public CSharpCastReducer() : base(s_pool)
         {
-            return new Rewriter(optionSet, cancellationToken);
         }
 
         private static readonly Func<CastExpressionSyntax, SemanticModel, OptionSet, CancellationToken, ExpressionSyntax> s_simplifyCast = SimplifyCast;
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpEscapingReducer.Rewriter.cs
similarity index 54%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.Rewriter.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpEscapingReducer.Rewriter.cs
index b4c07b6fd3750..9db3a35690159 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpEscapingReducer.Rewriter.cs
@@ -1,22 +1,18 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Threading;
-using Microsoft.CodeAnalysis.Options;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal partial class CSharpEscapingReducer
     {
-        private class Rewriter : AbstractExpressionRewriter
+        private class Rewriter : AbstractReductionRewriter
         {
-            public Rewriter(CSharpEscapingReducer escapingSimplifierService, OptionSet optionSet, CancellationToken cancellationToken)
-                : base(optionSet, cancellationToken)
+            public Rewriter(ObjectPool<IReductionRewriter> pool)
+                : base(pool)
             {
-                _escapingSimplifierService = escapingSimplifierService;
             }
 
-            private readonly CSharpEscapingReducer _escapingSimplifierService;
-
             public override SyntaxToken VisitToken(SyntaxToken token)
             {
                 var newToken = base.VisitToken(token);
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpEscapingReducer.cs
similarity index 96%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpEscapingReducer.cs
index b87d5a4b22cd9..b4473f26b5ddc 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpEscapingReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpEscapingReducer.cs
@@ -8,14 +8,17 @@
 using Microsoft.CodeAnalysis.CSharp.Utilities;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal partial class CSharpEscapingReducer : AbstractCSharpReducer
     {
-        public override IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet, CancellationToken cancellationToken)
+        private static readonly ObjectPool<IReductionRewriter> s_pool = new ObjectPool<IReductionRewriter>(
+            () => new Rewriter(s_pool));
+
+        public CSharpEscapingReducer() : base(s_pool)
         {
-            return new Rewriter(this, optionSet, cancellationToken);
         }
 
         private static Func<SyntaxToken, SemanticModel, OptionSet, CancellationToken, SyntaxToken> s_simplifyIdentifierToken = SimplifyIdentifierToken;
@@ -132,4 +135,4 @@ private static SyntaxToken CreateNewIdentifierTokenFromToken(SyntaxToken origina
                 : originalToken.CopyAnnotationsTo(SyntaxFactory.Identifier(originalToken.LeadingTrivia, SyntaxKind.IdentifierToken, unescapedText, originalToken.ValueText, originalToken.TrailingTrivia));
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpExtensionMethodReducer.Rewriter.cs
similarity index 73%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.Rewriter.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpExtensionMethodReducer.Rewriter.cs
index 624e77dcee453..62f8dc0b68393 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpExtensionMethodReducer.Rewriter.cs
@@ -1,17 +1,16 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Options;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal partial class CSharpExtensionMethodReducer
     {
-        private class Rewriter : AbstractExpressionRewriter
+        private class Rewriter : AbstractReductionRewriter
         {
-            public Rewriter(OptionSet optionSet, CancellationToken cancellationToken)
-                : base(optionSet, cancellationToken)
+            public Rewriter(ObjectPool<IReductionRewriter> pool)
+                : base(pool)
             {
             }
 
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpExtensionMethodReducer.cs
similarity index 94%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpExtensionMethodReducer.cs
index 15de394df2cf7..b9913bc6bc7fa 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpExtensionMethodReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpExtensionMethodReducer.cs
@@ -8,14 +8,17 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal partial class CSharpExtensionMethodReducer : AbstractCSharpReducer
     {
-        public override IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet, CancellationToken cancellationToken)
+        private static readonly ObjectPool<IReductionRewriter> s_pool = new ObjectPool<IReductionRewriter>(
+            () => new Rewriter(s_pool));
+
+        public CSharpExtensionMethodReducer() : base(s_pool)
         {
-            return new Rewriter(optionSet, cancellationToken);
         }
 
         private static readonly Func<InvocationExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyExtensionMethod = SimplifyExtensionMethod;
@@ -67,19 +70,19 @@ private static InvocationExpressionSyntax TryReduceExtensionMethod(InvocationExp
                         {
                             newMemberAccess = SyntaxFactory.MemberAccessExpression(
                                 SyntaxKind.SimpleMemberAccessExpression, expression,
-                                ((MemberAccessExpressionSyntax)invocationExpressionNodeExpression).OperatorToken, 
+                                ((MemberAccessExpressionSyntax)invocationExpressionNodeExpression).OperatorToken,
                                 ((MemberAccessExpressionSyntax)invocationExpressionNodeExpression).Name);
                         }
                         else if (node.Expression.Kind() == SyntaxKind.IdentifierName)
                         {
                             newMemberAccess = SyntaxFactory.MemberAccessExpression(
-                                SyntaxKind.SimpleMemberAccessExpression, expression, 
+                                SyntaxKind.SimpleMemberAccessExpression, expression,
                                 (IdentifierNameSyntax)invocationExpressionNodeExpression.WithoutLeadingTrivia());
                         }
                         else if (node.Expression.Kind() == SyntaxKind.GenericName)
                         {
                             newMemberAccess = SyntaxFactory.MemberAccessExpression(
-                                SyntaxKind.SimpleMemberAccessExpression, expression, 
+                                SyntaxKind.SimpleMemberAccessExpression, expression,
                                 (GenericNameSyntax)invocationExpressionNodeExpression.WithoutLeadingTrivia());
                         }
                         else
@@ -122,4 +125,4 @@ private static InvocationExpressionSyntax TryReduceExtensionMethod(InvocationExp
             return rewrittenNode;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpInferredMemberNameReducer.Rewriter.cs
old mode 100755
new mode 100644
similarity index 82%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.Rewriter.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpInferredMemberNameReducer.Rewriter.cs
index f19da855592f0..b4c98521bca6c
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpInferredMemberNameReducer.Rewriter.cs
@@ -1,18 +1,16 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System;
-using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Options;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal partial class CSharpInferredMemberNameReducer
     {
-        private class Rewriter : AbstractExpressionRewriter
+        private class Rewriter : AbstractReductionRewriter
         {
-            public Rewriter(OptionSet optionSet, CancellationToken cancellationToken)
-                : base(optionSet, cancellationToken)
+            public Rewriter(ObjectPool<IReductionRewriter> pool)
+                : base(pool)
             {
             }
 
@@ -42,4 +40,4 @@ public override SyntaxNode VisitAnonymousObjectMemberDeclarator(AnonymousObjectM
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpInferredMemberNameReducer.cs
old mode 100755
new mode 100644
similarity index 91%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpInferredMemberNameReducer.cs
index 3983736cf0d41..9d60e373a2beb
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpInferredMemberNameReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpInferredMemberNameReducer.cs
@@ -5,6 +5,7 @@
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Options;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
@@ -15,9 +16,11 @@ namespace Microsoft.CodeAnalysis.CSharp.Simplification
     /// </summary>
     internal partial class CSharpInferredMemberNameReducer : AbstractCSharpReducer
     {
-        public override IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet, CancellationToken cancellationToken)
+        private static readonly ObjectPool<IReductionRewriter> s_pool = new ObjectPool<IReductionRewriter>(
+            () => new Rewriter(s_pool));
+
+        public CSharpInferredMemberNameReducer() : base(s_pool)
         {
-            return new Rewriter(optionSet, cancellationToken);
         }
 
         private static readonly Func<ArgumentSyntax, SemanticModel, OptionSet, CancellationToken, ArgumentSyntax> s_simplifyTupleName = SimplifyTupleName;
@@ -59,4 +62,4 @@ private static SyntaxNode SimplifyAnonymousTypeMemberName(AnonymousObjectMemberD
             return node.WithNameEquals(null).WithTriviaFrom(node);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs
similarity index 80%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.Rewriter.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs
index c338efd9e1ccd..eab89aaac85ce 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs
@@ -1,17 +1,16 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Options;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal partial class CSharpMiscellaneousReducer
     {
-        private class Rewriter : AbstractExpressionRewriter
+        private class Rewriter : AbstractReductionRewriter
         {
-            public Rewriter(OptionSet optionSet, CancellationToken cancellationToken)
-                : base(optionSet, cancellationToken)
+            public Rewriter(ObjectPool<IReductionRewriter> pool)
+                : base(pool)
             {
             }
 
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
similarity index 95%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
index 4d3c315c30b31..f6e0e23cb9915 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpMiscellaneousReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
@@ -8,14 +8,17 @@
 using Microsoft.CodeAnalysis.CSharp.Utilities;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Simplification;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal partial class CSharpMiscellaneousReducer : AbstractCSharpReducer
     {
-        public override IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet, CancellationToken cancellationToken)
+        private static readonly ObjectPool<IReductionRewriter> s_pool = new ObjectPool<IReductionRewriter>(
+            () => new Rewriter(s_pool));
+
+        public CSharpMiscellaneousReducer() : base(s_pool)
         {
-            return new Rewriter(optionSet, cancellationToken);
         }
 
         private static bool CanRemoveTypeFromParameter(
@@ -101,4 +104,4 @@ private static SyntaxNode SimplifyParenthesizedLambdaExpression(
             return node;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpNameReducer.Rewriter.cs
similarity index 95%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.Rewriter.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpNameReducer.Rewriter.cs
index 87e19ddd40d73..98d9e5d17389b 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpNameReducer.Rewriter.cs
@@ -1,21 +1,19 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Threading;
-using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Formatting;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Simplification;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal partial class CSharpNameReducer
     {
-        private class Rewriter : AbstractExpressionRewriter
+        private class Rewriter : AbstractReductionRewriter
         {
-            public Rewriter(OptionSet optionSet, CancellationToken cancellationToken)
-                : base(optionSet, cancellationToken)
+            public Rewriter(ObjectPool<IReductionRewriter> pool)
+                : base(pool)
             {
             }
 
@@ -201,4 +199,4 @@ public override SyntaxNode VisitBinaryExpression(BinaryExpressionSyntax node)
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpNameReducer.cs
similarity index 90%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpNameReducer.cs
index d9bc79dfeea30..5248fa24eaf57 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpNameReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpNameReducer.cs
@@ -8,14 +8,17 @@
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Simplification;
 using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal partial class CSharpNameReducer : AbstractCSharpReducer
     {
-        public override IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet, CancellationToken cancellationToken)
+        private static readonly ObjectPool<IReductionRewriter> s_pool = new ObjectPool<IReductionRewriter>(
+            () => new Rewriter(s_pool));
+
+        public CSharpNameReducer() : base(s_pool)
         {
-            return new Rewriter(optionSet, cancellationToken);
         }
 
         private static readonly Func<SyntaxNode, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyName = SimplifyName;
@@ -54,4 +57,4 @@ private static SyntaxNode SimplifyName(
             return node.WithoutAnnotations(Simplifier.Annotation);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpParenthesesReducer.Rewriter.cs
similarity index 73%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.Rewriter.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpParenthesesReducer.Rewriter.cs
index c20a0b1c4c015..995eac3b5c4a5 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpParenthesesReducer.Rewriter.cs
@@ -1,17 +1,16 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Options;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal partial class CSharpParenthesesReducer
     {
-        private class Rewriter : AbstractExpressionRewriter
+        private class Rewriter : AbstractReductionRewriter
         {
-            public Rewriter(OptionSet optionSet, CancellationToken cancellationToken)
-                : base(optionSet, cancellationToken)
+            public Rewriter(ObjectPool<IReductionRewriter> pool)
+                : base(pool)
             {
             }
 
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpParenthesesReducer.cs
similarity index 91%
rename from src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.cs
rename to src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpParenthesesReducer.cs
index 1e525ed1fe5e1..4f35546c51e9a 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpParenthesesReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpParenthesesReducer.cs
@@ -8,14 +8,17 @@
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Simplification;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
     internal partial class CSharpParenthesesReducer : AbstractCSharpReducer
     {
-        public override IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet, CancellationToken cancellationToken)
+        private static readonly ObjectPool<IReductionRewriter> s_pool = new ObjectPool<IReductionRewriter>(
+            () => new Rewriter(s_pool));
+
+        public CSharpParenthesesReducer() : base(s_pool)
         {
-            return new Rewriter(optionSet, cancellationToken);
         }
 
         private static readonly Func<ParenthesizedExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyParentheses = SimplifyParentheses;
diff --git a/src/Workspaces/Core/Portable/Simplification/AbstractReducer.IExpressionRewriter.cs b/src/Workspaces/Core/Portable/Simplification/AbstractReducer.IExpressionRewriter.cs
index 8f8586fe1b8b2..c3e57a10aa5d5 100644
--- a/src/Workspaces/Core/Portable/Simplification/AbstractReducer.IExpressionRewriter.cs
+++ b/src/Workspaces/Core/Portable/Simplification/AbstractReducer.IExpressionRewriter.cs
@@ -1,14 +1,20 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
+using System.Threading;
+using Microsoft.CodeAnalysis.Options;
+
 namespace Microsoft.CodeAnalysis.Simplification
 {
     internal abstract partial class AbstractReducer
     {
-        internal interface IExpressionRewriter
+        internal interface IReductionRewriter : IDisposable
         {
+            void Initialize(OptionSet optionSet, CancellationToken cancellationToken);
+
             SyntaxNodeOrToken VisitNodeOrToken(SyntaxNodeOrToken nodeOrTokenToReduce, SemanticModel semanticModel, bool simplifyAllDescendants);
 
             bool HasMoreWork { get; }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/Core/Portable/Simplification/AbstractReducer.cs b/src/Workspaces/Core/Portable/Simplification/AbstractReducer.cs
index a24784daeaa9e..94b1992234788 100644
--- a/src/Workspaces/Core/Portable/Simplification/AbstractReducer.cs
+++ b/src/Workspaces/Core/Portable/Simplification/AbstractReducer.cs
@@ -1,12 +1,17 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Threading;
-using Microsoft.CodeAnalysis.Options;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Simplification
 {
     internal abstract partial class AbstractReducer
     {
-        public abstract IExpressionRewriter CreateExpressionRewriter(OptionSet optionSet, CancellationToken cancellationToken);
+        private readonly ObjectPool<IReductionRewriter> _pool;
+
+        protected AbstractReducer(ObjectPool<IReductionRewriter> pool)
+            => _pool = pool;
+
+        public IReductionRewriter GetOrCreateRewriter()
+            => _pool.Allocate();
     }
-}
+}
\ No newline at end of file
diff --git a/src/Workspaces/Core/Portable/Simplification/AbstractSimplificationService.cs b/src/Workspaces/Core/Portable/Simplification/AbstractSimplificationService.cs
index ac9b8cdb7a33e..96c5941cbbab3 100644
--- a/src/Workspaces/Core/Portable/Simplification/AbstractSimplificationService.cs
+++ b/src/Workspaces/Core/Portable/Simplification/AbstractSimplificationService.cs
@@ -163,7 +163,7 @@ private Task ReduceAsync(
             Document document,
             SyntaxNode root,
             ImmutableArray<NodeOrTokenToReduce> nodesAndTokensToReduce,
-            IEnumerable<AbstractReducer> reducers,
+            ImmutableArray<AbstractReducer> reducers,
             OptionSet optionSet,
             SemanticModel semanticModel,
             ConcurrentDictionary<SyntaxNode, SyntaxNode> reducedNodesMap,
@@ -178,89 +178,92 @@ private Task ReduceAsync(
             {
                 var nodeOrTokenToReduce = nodesAndTokensToReduce[i];
                 simplifyTasks[i] = Task.Run(async () =>
-            {
-                var nodeOrToken = nodeOrTokenToReduce.OriginalNodeOrToken;
-                var simplifyAllDescendants = nodeOrTokenToReduce.SimplifyAllDescendants;
-                var semanticModelForReduce = semanticModel;
-                var currentNodeOrToken = nodeOrTokenToReduce.NodeOrToken;
-                var isNode = nodeOrToken.IsNode;
-
-                foreach (var reducer in reducers)
                 {
-                    cancellationToken.ThrowIfCancellationRequested();
+                    var nodeOrToken = nodeOrTokenToReduce.OriginalNodeOrToken;
+                    var simplifyAllDescendants = nodeOrTokenToReduce.SimplifyAllDescendants;
+                    var semanticModelForReduce = semanticModel;
+                    var currentNodeOrToken = nodeOrTokenToReduce.NodeOrToken;
+                    var isNode = nodeOrToken.IsNode;
 
-                    var rewriter = reducer.CreateExpressionRewriter(optionSet, cancellationToken);
-
-                    do
+                    foreach (var reducer in reducers)
                     {
-                        if (currentNodeOrToken.SyntaxTree != semanticModelForReduce.SyntaxTree)
-                        {
-                            // currentNodeOrToken was simplified either by a previous reducer or
-                            // a previous iteration of the current reducer.
-                            // Create a speculative semantic model for the simplified node for semantic queries.
-
-                            // Certain node kinds (expressions/statements) require non-null parent nodes during simplification.
-                            // However, the reduced nodes haven't been parented yet, so do the required parenting using the original node's parent.
-                            if (currentNodeOrToken.Parent == null &&
-                                nodeOrToken.Parent != null &&
-                                (currentNodeOrToken.IsToken ||
-                                currentNodeOrToken.AsNode() is TExpressionSyntax ||
-                                currentNodeOrToken.AsNode() is TStatementSyntax ||
-                                currentNodeOrToken.AsNode() is TCrefSyntax))
-                            {
-                                var annotation = new SyntaxAnnotation();
-                                currentNodeOrToken = currentNodeOrToken.WithAdditionalAnnotations(annotation);
+                        cancellationToken.ThrowIfCancellationRequested();
 
-                                var replacedParent = isNode ?
-                                    nodeOrToken.Parent.ReplaceNode(nodeOrToken.AsNode(), currentNodeOrToken.AsNode()) :
-                                    nodeOrToken.Parent.ReplaceToken(nodeOrToken.AsToken(), currentNodeOrToken.AsToken());
-
-                                currentNodeOrToken = replacedParent
-                                    .ChildNodesAndTokens()
-                                    .Single((c) => c.HasAnnotation(annotation));
-                            }
+                        using (var rewriter = reducer.GetOrCreateRewriter())
+                        {
+                            rewriter.Initialize(optionSet, cancellationToken);
 
-                            if (isNode)
+                            do
                             {
-                                var currentNode = currentNodeOrToken.AsNode();
-                                if (this.CanNodeBeSimplifiedWithoutSpeculation(nodeOrToken.AsNode()))
-                                {
-                                    // Since this node cannot be speculated, we are replacing the Document with the changes and get a new SemanticModel
-                                    SyntaxAnnotation marker = new SyntaxAnnotation();
-                                    var newRoot = root.ReplaceNode(nodeOrToken.AsNode(), currentNode.WithAdditionalAnnotations(marker));
-                                    var newDocument = document.WithSyntaxRoot(newRoot);
-                                    semanticModelForReduce = await newDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-                                    newRoot = await semanticModelForReduce.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
-                                    currentNodeOrToken = newRoot.DescendantNodes().Single((c) => c.HasAnnotation(marker));
-                                }
-                                else
+                                if (currentNodeOrToken.SyntaxTree != semanticModelForReduce.SyntaxTree)
                                 {
-                                    // Create speculative semantic model for simplified node.
-                                    semanticModelForReduce = GetSpeculativeSemanticModel(ref currentNode, semanticModel, nodeOrToken.AsNode());
-                                    currentNodeOrToken = currentNode;
+                                    // currentNodeOrToken was simplified either by a previous reducer or
+                                    // a previous iteration of the current reducer.
+                                    // Create a speculative semantic model for the simplified node for semantic queries.
+
+                                    // Certain node kinds (expressions/statements) require non-null parent nodes during simplification.
+                                    // However, the reduced nodes haven't been parented yet, so do the required parenting using the original node's parent.
+                                    if (currentNodeOrToken.Parent == null &&
+                                        nodeOrToken.Parent != null &&
+                                        (currentNodeOrToken.IsToken ||
+                                        currentNodeOrToken.AsNode() is TExpressionSyntax ||
+                                        currentNodeOrToken.AsNode() is TStatementSyntax ||
+                                        currentNodeOrToken.AsNode() is TCrefSyntax))
+                                    {
+                                        var annotation = new SyntaxAnnotation();
+                                        currentNodeOrToken = currentNodeOrToken.WithAdditionalAnnotations(annotation);
+
+                                        var replacedParent = isNode ?
+                                            nodeOrToken.Parent.ReplaceNode(nodeOrToken.AsNode(), currentNodeOrToken.AsNode()) :
+                                            nodeOrToken.Parent.ReplaceToken(nodeOrToken.AsToken(), currentNodeOrToken.AsToken());
+
+                                        currentNodeOrToken = replacedParent
+                                            .ChildNodesAndTokens()
+                                            .Single((c) => c.HasAnnotation(annotation));
+                                    }
+
+                                    if (isNode)
+                                    {
+                                        var currentNode = currentNodeOrToken.AsNode();
+                                        if (this.CanNodeBeSimplifiedWithoutSpeculation(nodeOrToken.AsNode()))
+                                        {
+                                            // Since this node cannot be speculated, we are replacing the Document with the changes and get a new SemanticModel
+                                            SyntaxAnnotation marker = new SyntaxAnnotation();
+                                            var newRoot = root.ReplaceNode(nodeOrToken.AsNode(), currentNode.WithAdditionalAnnotations(marker));
+                                            var newDocument = document.WithSyntaxRoot(newRoot);
+                                            semanticModelForReduce = await newDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+                                            newRoot = await semanticModelForReduce.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
+                                            currentNodeOrToken = newRoot.DescendantNodes().Single((c) => c.HasAnnotation(marker));
+                                        }
+                                        else
+                                        {
+                                            // Create speculative semantic model for simplified node.
+                                            semanticModelForReduce = GetSpeculativeSemanticModel(ref currentNode, semanticModel, nodeOrToken.AsNode());
+                                            currentNodeOrToken = currentNode;
+                                        }
+                                    }
                                 }
+
+                                // Reduce the current node or token.
+                                currentNodeOrToken = rewriter.VisitNodeOrToken(currentNodeOrToken, semanticModelForReduce, simplifyAllDescendants);
                             }
+                            while (rewriter.HasMoreWork);
                         }
-
-                        // Reduce the current node or token.
-                        currentNodeOrToken = rewriter.VisitNodeOrToken(currentNodeOrToken, semanticModelForReduce, simplifyAllDescendants);
                     }
-                    while (rewriter.HasMoreWork);
-                }
 
-                // If nodeOrToken was simplified, add it to the appropriate dictionary of replaced nodes/tokens.
-                if (currentNodeOrToken != nodeOrToken)
-                {
-                    if (isNode)
-                    {
-                        reducedNodesMap[nodeOrToken.AsNode()] = currentNodeOrToken.AsNode();
-                    }
-                    else
+                    // If nodeOrToken was simplified, add it to the appropriate dictionary of replaced nodes/tokens.
+                    if (currentNodeOrToken != nodeOrToken)
                     {
-                        reducedTokensMap[nodeOrToken.AsToken()] = currentNodeOrToken.AsToken();
+                        if (isNode)
+                        {
+                            reducedNodesMap[nodeOrToken.AsNode()] = currentNodeOrToken.AsNode();
+                        }
+                        else
+                        {
+                            reducedTokensMap[nodeOrToken.AsToken()] = currentNodeOrToken.AsToken();
+                        }
                     }
-                }
-            }, cancellationToken);
+                }, cancellationToken);
             }
 
             return Task.WhenAll(simplifyTasks);
diff --git a/src/Workspaces/VisualBasic/Portable/BasicWorkspace.vbproj b/src/Workspaces/VisualBasic/Portable/BasicWorkspace.vbproj
index db2cf36f964f2..f220e38764338 100644
--- a/src/Workspaces/VisualBasic/Portable/BasicWorkspace.vbproj
+++ b/src/Workspaces/VisualBasic/Portable/BasicWorkspace.vbproj
@@ -184,29 +184,29 @@
     <Compile Include="Rename\LocalConflictVisitor.vb" />
     <Compile Include="Rename\VisualBasicRenameRewriterLanguageService.vb" />
     <Compile Include="Rename\VisualBasicRenameRewriterLanguageServiceFactory.vb" />
-    <Compile Include="Simplification\AbstractVisualBasicReducer.vb" />
-    <Compile Include="Simplification\AbstractVisualBasicSimplifier.AbstractExpressionRewriter.vb" />
-    <Compile Include="Simplification\VisualBasicCallReducer.Rewriter.vb" />
-    <Compile Include="Simplification\VisualBasicCallReducer.vb" />
-    <Compile Include="Simplification\VisualBasicCastReducer.Rewriter.vb" />
-    <Compile Include="Simplification\VisualBasicCastReducer.vb" />
-    <Compile Include="Simplification\VisualBasicInferredMemberNameReducer.vb" />
-    <Compile Include="Simplification\VisualBasicInferredMemberNameReducer.Rewriter.vb" />
-    <Compile Include="Simplification\VisualBasicEscapingReducer.Rewriter.vb" />
-    <Compile Include="Simplification\VisualBasicEscapingReducer.vb" />
-    <Compile Include="Simplification\VisualBasicExtensionMethodReducer.Rewriter.vb" />
-    <Compile Include="Simplification\VisualBasicExtensionMethodReducer.vb" />
-    <Compile Include="Simplification\VisualBasicMiscellaneousReducer.Rewriter.vb" />
-    <Compile Include="Simplification\VisualBasicMiscellaneousReducer.vb" />
-    <Compile Include="Simplification\VisualBasicNameReducer.Rewriter.vb" />
-    <Compile Include="Simplification\VisualBasicNameReducer.vb" />
-    <Compile Include="Simplification\VisualBasicParenthesesReducer.Rewriter.vb" />
-    <Compile Include="Simplification\VisualBasicParenthesesReducer.vb" />
+    <Compile Include="Simplification\Reducers\AbstractVisualBasicReducer.AbstractReductionRewriter.vb" />
+    <Compile Include="Simplification\Reducers\AbstractVisualBasicReducer.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicCallReducer.Rewriter.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicCallReducer.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicCastReducer.Rewriter.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicCastReducer.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicInferredMemberNameReducer.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicInferredMemberNameReducer.Rewriter.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicEscapingReducer.Rewriter.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicEscapingReducer.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicExtensionMethodReducer.Rewriter.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicExtensionMethodReducer.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicMiscellaneousReducer.Rewriter.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicMiscellaneousReducer.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicNameReducer.Rewriter.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicNameReducer.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicParenthesesReducer.Rewriter.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicParenthesesReducer.vb" />
     <Compile Include="Simplification\VisualBasicSimplificationService.Expander.vb" />
     <Compile Include="Simplification\VisualBasicSimplificationService.NodesAndTokensToReduceComputer.vb" />
     <Compile Include="Simplification\VisualBasicSimplificationService.vb" />
-    <Compile Include="Simplification\VisualBasicVariableDeclaratorReducer.Rewriter.vb" />
-    <Compile Include="Simplification\VisualBasicVariableDeclaratorReducer.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicVariableDeclaratorReducer.Rewriter.vb" />
+    <Compile Include="Simplification\Reducers\VisualBasicVariableDeclaratorReducer.vb" />
     <Compile Include="Utilities\DirectiveSyntaxEqualityComparer.vb" />
     <Compile Include="Utilities\DirectiveWalker.vb" />
     <Compile Include="Utilities\ImportsClauseComparer.vb" />
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/AbstractVisualBasicSimplifier.AbstractExpressionRewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/AbstractVisualBasicReducer.AbstractReductionRewriter.vb
similarity index 86%
rename from src/Workspaces/VisualBasic/Portable/Simplification/AbstractVisualBasicSimplifier.AbstractExpressionRewriter.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/AbstractVisualBasicReducer.AbstractReductionRewriter.vb
index 919887d6b4b07..b3495c1852870 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/AbstractVisualBasicSimplifier.AbstractExpressionRewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/AbstractVisualBasicReducer.AbstractReductionRewriter.vb
@@ -7,25 +7,43 @@ Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend MustInherit Class AbstractVisualBasicReducer
-        Friend MustInherit Class AbstractExpressionRewriter
+        Friend MustInherit Class AbstractReductionRewriter
             Inherits VisualBasicSyntaxRewriter
-            Implements IExpressionRewriter
+            Implements IReductionRewriter
+
+            Private ReadOnly _pool As ObjectPool(Of IReductionRewriter)
+
+            Protected CancellationToken As CancellationToken
+            Private _simplificationOptions As OptionSet
+
+            Private ReadOnly _processedParentNodes As HashSet(Of SyntaxNode) = New HashSet(Of SyntaxNode)()
+            Private _semanticModel As SemanticModel
 
-            Protected ReadOnly CancellationToken As CancellationToken
-            Private ReadOnly _processedParentNodes As HashSet(Of SyntaxNode)
             Private _hasMoreWork As Boolean
             Protected _alwaysSimplify As Boolean
-            Private ReadOnly _simplificationOptions As OptionSet
-            Private _semanticModel As SemanticModel
 
-            Protected Sub New(optionSet As OptionSet, cancellationToken As CancellationToken)
-                MyBase.New()
-                Me.CancellationToken = cancellationToken
-                Me._simplificationOptions = optionSet
-                _processedParentNodes = New HashSet(Of SyntaxNode)
+            Protected Sub New(pool As ObjectPool(Of IReductionRewriter))
+                _pool = pool
+            End Sub
+
+            Public Sub Initialize(optionSet As OptionSet, cancellationToken As CancellationToken) Implements IReductionRewriter.Initialize
+                _simplificationOptions = optionSet
+                cancellationToken = cancellationToken
+            End Sub
+
+            Public Sub Dispose() Implements IDisposable.Dispose
+                _simplificationOptions = Nothing
+                CancellationToken = CancellationToken.None
+                _processedParentNodes.Clear()
+                _semanticModel = Nothing
+
+                _hasMoreWork = False
+                _alwaysSimplify = False
+
+                _pool.Free(Me)
             End Sub
 
-            Public ReadOnly Property HasMoreWork As Boolean Implements IExpressionRewriter.HasMoreWork
+            Public ReadOnly Property HasMoreWork As Boolean Implements IReductionRewriter.HasMoreWork
                 Get
                     Return _hasMoreWork
                 End Get
@@ -140,8 +158,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 Return SimplifyNode(statement, newNode, GetParentNode(statement), simplifier)
             End Function
 
-            Public Function VisitNodeOrToken(nodeOrToken As SyntaxNodeOrToken, semanticModel As SemanticModel, simplifyAllDescendants As Boolean) As SyntaxNodeOrToken Implements IExpressionRewriter.VisitNodeOrToken
-                _semanticModel = DirectCast(semanticModel, semanticModel)
+            Public Function VisitNodeOrToken(nodeOrToken As SyntaxNodeOrToken, semanticModel As SemanticModel, simplifyAllDescendants As Boolean) As SyntaxNodeOrToken Implements IReductionRewriter.VisitNodeOrToken
+                _semanticModel = DirectCast(semanticModel, SemanticModel)
                 _alwaysSimplify = simplifyAllDescendants
                 _hasMoreWork = False
                 _processedParentNodes.Clear()
@@ -186,4 +204,4 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             End Function
         End Class
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/AbstractVisualBasicReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/AbstractVisualBasicReducer.vb
similarity index 95%
rename from src/Workspaces/VisualBasic/Portable/Simplification/AbstractVisualBasicReducer.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/AbstractVisualBasicReducer.vb
index 0212ce261c265..6b8868ddc0975 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/AbstractVisualBasicReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/AbstractVisualBasicReducer.vb
@@ -9,6 +9,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend MustInherit Class AbstractVisualBasicReducer
         Inherits AbstractReducer
 
+        Protected Sub New(pool As ObjectPool(Of IReductionRewriter))
+            MyBase.New(pool)
+        End Sub
+
         Protected Shared ReadOnly s_reduceParentheses As Func(Of ParenthesizedExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf ReduceParentheses
 
         Protected Shared Function ReduceParentheses(
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCallReducer.Rewriter.vb
similarity index 80%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.Rewriter.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCallReducer.Rewriter.vb
index 5b1aef9915c0d..ecc4d1bdeee88 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCallReducer.Rewriter.vb
@@ -1,16 +1,14 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-Imports System.Threading
-Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicCallReducer
         Private Class Rewriter
-            Inherits AbstractExpressionRewriter
+            Inherits AbstractReductionRewriter
 
-            Public Sub New(optionSet As OptionSet, cancellationToken As CancellationToken)
-                MyBase.New(optionSet, cancellationToken)
+            Public Sub New(pool As ObjectPool(Of IReductionRewriter))
+                MyBase.New(pool)
             End Sub
 
             Public Overrides Function VisitCallStatement(node As CallStatementSyntax) As SyntaxNode
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCallReducer.vb
similarity index 85%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCallReducer.vb
index 3f8be8e1277f0..57ecc9e254ccc 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCallReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCallReducer.vb
@@ -9,9 +9,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicCallReducer
         Inherits AbstractVisualBasicReducer
 
-        Public Overrides Function CreateExpressionRewriter(optionSet As OptionSet, cancellationToken As CancellationToken) As IExpressionRewriter
-            Return New Rewriter(optionSet, cancellationToken)
-        End Function
+        Private Shared ReadOnly s_pool As ObjectPool(Of IReductionRewriter) =
+            New ObjectPool(Of IReductionRewriter)(Function() New Rewriter(s_pool))
+
+        Public Sub New()
+            MyBase.New(s_pool)
+        End Sub
 
         Private Shared ReadOnly s_simplifyCallStatement As Func(Of CallStatementSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyCallStatement
 
@@ -36,6 +39,5 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             ' We don't know how to simplify this.
             Return callStatement
         End Function
-
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCastReducer.Rewriter.vb
similarity index 86%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.Rewriter.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCastReducer.Rewriter.vb
index cd876badbc161..583f01700aa68 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCastReducer.Rewriter.vb
@@ -1,16 +1,14 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-Imports System.Threading
-Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicCastReducer
         Private Class Rewriter
-            Inherits AbstractExpressionRewriter
+            Inherits AbstractReductionRewriter
 
-            Public Sub New(optionSet As OptionSet, cancellationToken As CancellationToken)
-                MyBase.New(optionSet, cancellationToken)
+            Public Sub New(pool As ObjectPool(Of IReductionRewriter))
+                MyBase.New(pool)
             End Sub
 
             Public Overrides Function VisitCTypeExpression(node As CTypeExpressionSyntax) As SyntaxNode
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCastReducer.vb
similarity index 91%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCastReducer.vb
index 5b968bf017042..b2adc52b8021d 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCastReducer.vb
@@ -9,9 +9,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicCastReducer
         Inherits AbstractVisualBasicReducer
 
-        Public Overrides Function CreateExpressionRewriter(optionSet As OptionSet, cancellationToken As CancellationToken) As IExpressionRewriter
-            Return New Rewriter(optionSet, cancellationToken)
-        End Function
+        Private Shared ReadOnly s_pool As ObjectPool(Of IReductionRewriter) =
+            New ObjectPool(Of IReductionRewriter)(Function() New Rewriter(s_pool))
+
+        Public Sub New()
+            MyBase.New(s_pool)
+        End Sub
 
         Private Overloads Shared Function SimplifyCast(
             castNode As ExpressionSyntax,
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicEscapingReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicEscapingReducer.Rewriter.vb
similarity index 74%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicEscapingReducer.Rewriter.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicEscapingReducer.Rewriter.vb
index a92543df6e1c7..1e050b52d51cd 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicEscapingReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicEscapingReducer.Rewriter.vb
@@ -1,15 +1,14 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports System.Threading
-Imports Microsoft.CodeAnalysis.Options
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicEscapingReducer
         Private Class Rewriter
-            Inherits AbstractExpressionRewriter
+            Inherits AbstractReductionRewriter
 
-            Public Sub New(optionSet As OptionSet, cancellationToken As CancellationToken)
-                MyBase.New(optionSet, cancellationToken)
+            Public Sub New(pool As ObjectPool(Of IReductionRewriter))
+                MyBase.New(pool)
             End Sub
 
             Public Overrides Function VisitToken(token As SyntaxToken) As SyntaxToken
@@ -20,7 +19,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                     newToken:=MyBase.VisitToken(token),
                     simplifyFunc:=AddressOf TryUnescapeToken)
             End Function
-
         End Class
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicEscapingReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicEscapingReducer.vb
similarity index 96%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicEscapingReducer.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicEscapingReducer.vb
index 96f0f0080b6cf..d1639ce90cedb 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicEscapingReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicEscapingReducer.vb
@@ -3,17 +3,18 @@
 Imports System.Threading
 Imports Microsoft.CodeAnalysis
 Imports Microsoft.CodeAnalysis.Options
-Imports Microsoft.CodeAnalysis.Simplification
-Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicEscapingReducer
         Inherits AbstractVisualBasicReducer
 
-        Public Overrides Function CreateExpressionRewriter(optionSet As OptionSet, cancellationToken As CancellationToken) As IExpressionRewriter
-            Return New VisualBasicEscapingReducer.Rewriter(optionSet, cancellationToken)
-        End Function
+        Private Shared ReadOnly s_pool As ObjectPool(Of IReductionRewriter) =
+            New ObjectPool(Of IReductionRewriter)(Function() New Rewriter(s_pool))
+
+        Public Sub New()
+            MyBase.New(s_pool)
+        End Sub
 
         Private Shared Function TryUnescapeToken(identifier As SyntaxToken, semanticModel As SemanticModel, optionSet As OptionSet, cancellationToken As CancellationToken) As SyntaxToken
             If Not identifier.IsBracketed Then
@@ -216,4 +217,4 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return False
         End Function
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicExtensionMethodReducer.Rewriter.vb
similarity index 78%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.Rewriter.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicExtensionMethodReducer.Rewriter.vb
index 7c82c5718df76..3d1365ce118ba 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicExtensionMethodReducer.Rewriter.vb
@@ -1,16 +1,15 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports System.Threading
-Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicExtensionMethodReducer
         Private Class Rewriter
-            Inherits AbstractExpressionRewriter
+            Inherits AbstractReductionRewriter
 
-            Public Sub New(optionSet As OptionSet, cancellationToken As CancellationToken)
-                MyBase.New(optionSet, cancellationToken)
+            Public Sub New(pool As ObjectPool(Of IReductionRewriter))
+                MyBase.New(pool)
             End Sub
 
             Public Overrides Function VisitInvocationExpression(node As InvocationExpressionSyntax) As SyntaxNode
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicExtensionMethodReducer.vb
similarity index 93%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicExtensionMethodReducer.vb
index 4117cc5c82c1a..c9cb45c1eb8e1 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicExtensionMethodReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicExtensionMethodReducer.vb
@@ -8,9 +8,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicExtensionMethodReducer
         Inherits AbstractVisualBasicReducer
 
-        Public Overrides Function CreateExpressionRewriter(optionSet As OptionSet, cancellationToken As CancellationToken) As IExpressionRewriter
-            Return New Rewriter(optionSet, cancellationToken)
-        End Function
+        Private Shared ReadOnly s_pool As ObjectPool(Of IReductionRewriter) =
+            New ObjectPool(Of IReductionRewriter)(Function() New Rewriter(s_pool))
+
+        Public Sub New()
+            MyBase.New(s_pool)
+        End Sub
 
         Private Shared ReadOnly s_simplifyInvocationExpression As Func(Of InvocationExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyInvocationExpression
 
@@ -61,6 +64,5 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
 
             Return rewrittenNode
         End Function
-
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicInferredMemberNameReducer.Rewriter.vb
similarity index 85%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.Rewriter.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicInferredMemberNameReducer.Rewriter.vb
index 84b9c68f0ee09..c85451f744a54 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicInferredMemberNameReducer.Rewriter.vb
@@ -1,17 +1,16 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports System.Threading
-Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicInferredMemberNameReducer
 
         Private Class Rewriter
-            Inherits AbstractExpressionRewriter
+            Inherits AbstractReductionRewriter
 
-            Public Sub New(optionSet As OptionSet, cancellationToken As CancellationToken)
-                MyBase.New(optionSet, cancellationToken)
+            Public Sub New(pool As ObjectPool(Of IReductionRewriter))
+                MyBase.New(pool)
             End Sub
 
             Public Overrides Function VisitSimpleArgument(node As SimpleArgumentSyntax) As SyntaxNode
@@ -41,4 +40,4 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             End Function
         End Class
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicInferredMemberNameReducer.vb
similarity index 90%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicInferredMemberNameReducer.vb
index 97f1ff8b4ccf5..1bc3da7b7cda7 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicInferredMemberNameReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicInferredMemberNameReducer.vb
@@ -14,9 +14,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicInferredMemberNameReducer
         Inherits AbstractVisualBasicReducer
 
-        Public Overrides Function CreateExpressionRewriter(optionSet As OptionSet, cancellationToken As CancellationToken) As IExpressionRewriter
-            Return New VisualBasicInferredMemberNameReducer.Rewriter(optionSet, cancellationToken)
-        End Function
+        Private Shared ReadOnly s_pool As ObjectPool(Of IReductionRewriter) =
+            New ObjectPool(Of IReductionRewriter)(Function() New Rewriter(s_pool))
+
+        Public Sub New()
+            MyBase.New(s_pool)
+        End Sub
 
         Private Shared ReadOnly s_simplifyTupleName As Func(Of SimpleArgumentSyntax, SemanticModel, OptionSet, CancellationToken, SimpleArgumentSyntax) = AddressOf SimplifyTupleName
 
@@ -56,4 +59,4 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return SyntaxFactory.InferredFieldInitializer(node.Expression).WithTriviaFrom(node)
         End Function
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicMiscellaneousReducer.Rewriter.vb
similarity index 87%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.Rewriter.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicMiscellaneousReducer.Rewriter.vb
index 05ae22615b503..873dc98961023 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicMiscellaneousReducer.Rewriter.vb
@@ -1,16 +1,15 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports System.Threading
-Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicMiscellaneousReducer
         Private Class Rewriter
-            Inherits AbstractExpressionRewriter
+            Inherits AbstractReductionRewriter
 
-            Public Sub New(optionSet As OptionSet, cancellationToken As CancellationToken)
-                MyBase.New(optionSet, cancellationToken)
+            Public Sub New(pool As ObjectPool(Of IReductionRewriter))
+                MyBase.New(pool)
             End Sub
 
             Public Overrides Function VisitInvocationExpression(node As InvocationExpressionSyntax) As SyntaxNode
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicMiscellaneousReducer.vb
similarity index 93%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicMiscellaneousReducer.vb
index 4589357439bd1..08973c38d1ba0 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicMiscellaneousReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicMiscellaneousReducer.vb
@@ -9,9 +9,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicMiscellaneousReducer
         Inherits AbstractVisualBasicReducer
 
-        Public Overrides Function CreateExpressionRewriter(optionSet As OptionSet, cancellationToken As CancellationToken) As IExpressionRewriter
-            Return New Rewriter(optionSet, cancellationToken)
-        End Function
+        Private Shared ReadOnly s_pool As ObjectPool(Of IReductionRewriter) =
+            New ObjectPool(Of IReductionRewriter)(Function() New Rewriter(s_pool))
+
+        Public Sub New()
+            MyBase.New(s_pool)
+        End Sub
 
         Private Shared ReadOnly s_simplifyParameter As Func(Of ParameterSyntax, SemanticModel, OptionSet, CancellationToken, ParameterSyntax) = AddressOf SimplifyParameter
 
@@ -75,6 +78,5 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             ' We don't know how to simplify this.
             Return objectCreationExpression
         End Function
-
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicNameReducer.Rewriter.vb
similarity index 93%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.Rewriter.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicNameReducer.Rewriter.vb
index 0e6d8abba873b..12705b4346bf0 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicNameReducer.Rewriter.vb
@@ -1,17 +1,15 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-Imports System.Threading
-Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.CodeAnalysis.Simplification
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicNameReducer
         Private Class Rewriter
-            Inherits AbstractExpressionRewriter
+            Inherits AbstractReductionRewriter
 
-            Public Sub New(optionSet As OptionSet, cancellationToken As CancellationToken)
-                MyBase.New(optionSet, cancellationToken)
+            Public Sub New(pool As ObjectPool(Of IReductionRewriter))
+                MyBase.New(pool)
             End Sub
 
             Public Overrides Function VisitGenericName(node As GenericNameSyntax) As SyntaxNode
@@ -109,7 +107,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
 
                 Return result
             End Function
-
         End Class
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicNameReducer.vb
similarity index 87%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicNameReducer.vb
index c31bb23a9e74e..e705d2f9efc85 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicNameReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicNameReducer.vb
@@ -12,9 +12,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicNameReducer
         Inherits AbstractVisualBasicReducer
 
-        Public Overrides Function CreateExpressionRewriter(optionSet As OptionSet, cancellationToken As CancellationToken) As IExpressionRewriter
-            Return New Rewriter(optionSet, cancellationToken)
-        End Function
+        Private Shared ReadOnly s_pool As ObjectPool(Of IReductionRewriter) =
+            New ObjectPool(Of IReductionRewriter)(Function() New Rewriter(s_pool))
+
+        Public Sub New()
+            MyBase.New(s_pool)
+        End Sub
 
         Private Shared ReadOnly s_simplifyName As Func(Of ExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyName
 
@@ -39,6 +42,5 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             node = node.CopyAnnotationsTo(replacementNode).WithAdditionalAnnotations(Formatter.Annotation)
             Return node.WithoutAnnotations(Simplifier.Annotation)
         End Function
-
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicParenthesesReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicParenthesesReducer.Rewriter.vb
similarity index 74%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicParenthesesReducer.Rewriter.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicParenthesesReducer.Rewriter.vb
index 7766e4a29ba78..fcec66136a35c 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicParenthesesReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicParenthesesReducer.Rewriter.vb
@@ -1,16 +1,14 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-Imports System.Threading
-Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicParenthesesReducer
         Private Class Rewriter
-            Inherits AbstractExpressionRewriter
+            Inherits AbstractReductionRewriter
 
-            Public Sub New(optionSet As OptionSet, cancellationToken As CancellationToken)
-                MyBase.New(optionSet, cancellationToken)
+            Public Sub New(pool As ObjectPool(Of IReductionRewriter))
+                MyBase.New(pool)
             End Sub
 
             Public Overrides Function VisitParenthesizedExpression(node As ParenthesizedExpressionSyntax) As SyntaxNode
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicParenthesesReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicParenthesesReducer.vb
similarity index 52%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicParenthesesReducer.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicParenthesesReducer.vb
index 59cce7f2fe698..6a04e9558ca2c 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicParenthesesReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicParenthesesReducer.vb
@@ -1,15 +1,14 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-Imports System.Threading
-Imports Microsoft.CodeAnalysis.Options
-
 Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicParenthesesReducer
         Inherits AbstractVisualBasicReducer
 
-        Public Overrides Function CreateExpressionRewriter(optionSet As OptionSet, cancellationToken As CancellationToken) As IExpressionRewriter
-            Return New Rewriter(optionSet, cancellationToken)
-        End Function
+        Private Shared ReadOnly s_pool As ObjectPool(Of IReductionRewriter) =
+            New ObjectPool(Of IReductionRewriter)(Function() New Rewriter(s_pool))
 
+        Public Sub New()
+            MyBase.New(s_pool)
+        End Sub
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.Rewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicVariableDeclaratorReducer.Rewriter.vb
similarity index 71%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.Rewriter.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicVariableDeclaratorReducer.Rewriter.vb
index 3236a101873a0..5a36bd6869ca3 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.Rewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicVariableDeclaratorReducer.Rewriter.vb
@@ -1,17 +1,14 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-Imports Microsoft.CodeAnalysis.Simplification
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
-Imports System.Threading
-Imports Microsoft.CodeAnalysis.Options
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicVariableDeclaratorReducer
         Private Class Rewriter
-            Inherits AbstractExpressionRewriter
+            Inherits AbstractReductionRewriter
 
-            Public Sub New(optionSet As OptionSet, cancellationToken As CancellationToken)
-                MyBase.New(optionSet, cancellationToken)
+            Public Sub New(pool As ObjectPool(Of IReductionRewriter))
+                MyBase.New(pool)
             End Sub
 
             Public Overrides Function VisitVariableDeclarator(node As VariableDeclaratorSyntax) As SyntaxNode
@@ -23,4 +20,4 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             End Function
         End Class
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicVariableDeclaratorReducer.vb
similarity index 86%
rename from src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.vb
rename to src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicVariableDeclaratorReducer.vb
index a9204fae01301..87506e172b302 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicVariableDeclaratorReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicVariableDeclaratorReducer.vb
@@ -11,9 +11,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
     Partial Friend Class VisualBasicVariableDeclaratorReducer
         Inherits AbstractVisualBasicReducer
 
-        Public Overrides Function CreateExpressionRewriter(optionSet As OptionSet, cancellationToken As CancellationToken) As IExpressionRewriter
-            Return New Rewriter(optionSet, cancellationToken)
-        End Function
+        Private Shared ReadOnly s_pool As ObjectPool(Of IReductionRewriter) =
+            New ObjectPool(Of IReductionRewriter)(Function() New Rewriter(s_pool))
+
+        Public Sub New()
+            MyBase.New(s_pool)
+        End Sub
 
         Private Shared ReadOnly s_simplifyVariableDeclarator As Func(Of VariableDeclaratorSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyVariableDeclarator
 
@@ -39,5 +42,4 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return replacementNode.WithoutAnnotations(Simplifier.Annotation)
         End Function
     End Class
-End Namespace
-
+End Namespace
\ No newline at end of file

From be8d91b6b7e08e5b1a026de636ab8e9f38291758 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 18:49:36 -0700
Subject: [PATCH 118/284] Fix null ref.

---
 .../Portable/Simplification/Reducers/VisualBasicCastReducer.vb  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCastReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCastReducer.vb
index b2adc52b8021d..131f28659c2bd 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCastReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/VisualBasicCastReducer.vb
@@ -32,7 +32,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return resultNode
         End Function
 
-        Private Shared ReadOnly s_simplifyCast As Func(Of CastExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = s_simplifyCast
+        Private Shared ReadOnly s_simplifyCast As Func(Of CastExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyCast
 
         Private Overloads Shared Function SimplifyCast(
             node As CastExpressionSyntax,

From ea768e052c5083e17920adb2b73836c70f9c9217 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 18:49:36 -0700
Subject: [PATCH 119/284] Fix null ref.

---
 .../Portable/Simplification/VisualBasicCastReducer.vb           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.vb b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.vb
index 5b968bf017042..ceb8f74b2150f 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/VisualBasicCastReducer.vb
@@ -29,7 +29,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Return resultNode
         End Function
 
-        Private Shared ReadOnly s_simplifyCast As Func(Of CastExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = s_simplifyCast
+        Private Shared ReadOnly s_simplifyCast As Func(Of CastExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode) = AddressOf SimplifyCast
 
         Private Overloads Shared Function SimplifyCast(
             node As CastExpressionSyntax,

From db8ed0ffb9655a7f07e26ea8f47798e70bf314b2 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 18:52:43 -0700
Subject: [PATCH 120/284] Revert change.

---
 .../CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs   | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
index 276ac06c8ff00..c85c224bc1b65 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
@@ -3524,7 +3524,9 @@ public override SyntaxNode IfStatement(SyntaxNode condition, IEnumerable<SyntaxN
         }
 
         private BlockSyntax CreateBlock(IEnumerable<SyntaxNode> statements)
-            => SyntaxFactory.Block(AsStatementList(statements)).WithAdditionalAnnotations(Simplifier.Annotation);
+        {
+            return SyntaxFactory.Block(AsStatementList(statements));
+        }
 
         private SyntaxList<StatementSyntax> AsStatementList(IEnumerable<SyntaxNode> nodes)
         {

From 451641b3ab82b091736e3129b5cf88bd970e2106 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 10 May 2017 21:20:03 -0700
Subject: [PATCH 121/284] Respect user settings around 'Blocks' when adding
 parameter null checks.

---
 .../AddParameterCheckTests.cs                 | 29 +++++++
 .../CodeGeneration/CSharpSyntaxGenerator.cs   |  4 +-
 .../CSharpMiscellaneousReducer.Rewriter.cs    |  9 ++
 .../Reducers/CSharpMiscellaneousReducer.cs    | 86 +++++++++++++------
 4 files changed, 100 insertions(+), 28 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/InitializeParameter/AddParameterCheckTests.cs b/src/EditorFeatures/CSharpTest/InitializeParameter/AddParameterCheckTests.cs
index b700377c7cebf..7241d5f7c5821 100644
--- a/src/EditorFeatures/CSharpTest/InitializeParameter/AddParameterCheckTests.cs
+++ b/src/EditorFeatures/CSharpTest/InitializeParameter/AddParameterCheckTests.cs
@@ -755,5 +755,34 @@ static void Main(String bar)
             CodeStyleOptions.PreferIntrinsicPredefinedTypeKeywordInMemberAccess,
             CodeStyleOptions.FalseWithSuggestionEnforcement)));
         }
+
+        [WorkItem(19172, "https://github.com/dotnet/roslyn/issues/19172")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
+        public async Task TestPreferNoBlock()
+        {
+            await TestInRegularAndScript1Async(
+@"
+using System;
+
+class C
+{
+    public C([||]string s)
+    {
+    }
+}",
+@"
+using System;
+
+class C
+{
+    public C(string s)
+    {
+        if (s == null)
+            throw new ArgumentNullException(nameof(s));
+    }
+}", ignoreTrivia: false,
+    parameters: new TestParameters(options:
+        Option(CSharpCodeStyleOptions.PreferBraces, CodeStyleOptions.FalseWithNoneEnforcement)));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
index c85c224bc1b65..276ac06c8ff00 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
@@ -3524,9 +3524,7 @@ public override SyntaxNode IfStatement(SyntaxNode condition, IEnumerable<SyntaxN
         }
 
         private BlockSyntax CreateBlock(IEnumerable<SyntaxNode> statements)
-        {
-            return SyntaxFactory.Block(AsStatementList(statements));
-        }
+            => SyntaxFactory.Block(AsStatementList(statements)).WithAdditionalAnnotations(Simplifier.Annotation);
 
         private SyntaxList<StatementSyntax> AsStatementList(IEnumerable<SyntaxNode> nodes)
         {
diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs
index eab89aaac85ce..c8a1d670ce039 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs
@@ -31,6 +31,15 @@ public override SyntaxNode VisitParenthesizedLambdaExpression(ParenthesizedLambd
                     parentNode: node.Parent,
                     simplifier: s_simplifyParenthesizedLambdaExpression);
             }
+
+            public override SyntaxNode VisitBlock(BlockSyntax node)
+            {
+                return SimplifyNode(
+                    node,
+                    newNode: base.VisitBlock(node),
+                    parentNode: node.Parent,
+                    simplifier: s_simplifyBlock);
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
index f6e0e23cb9915..931a90684ed35 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
@@ -3,6 +3,7 @@
 using System;
 using System.Linq;
 using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Utilities;
@@ -22,20 +23,20 @@ public CSharpMiscellaneousReducer() : base(s_pool)
         }
 
         private static bool CanRemoveTypeFromParameter(
-            SyntaxNode node,
+            ParameterSyntax parameterSyntax,
             SemanticModel semanticModel,
             CancellationToken cancellationToken)
         {
             // We reduce any the parameters that are contained inside ParameterList
-            if (node != null && node.IsParentKind(SyntaxKind.ParameterList) && node.Parent.IsParentKind(SyntaxKind.ParenthesizedLambdaExpression))
+            if (parameterSyntax.IsParentKind(SyntaxKind.ParameterList) &&
+                parameterSyntax.Parent.IsParentKind(SyntaxKind.ParenthesizedLambdaExpression))
             {
-                var parameterSyntax = (ParameterSyntax)node;
                 if (parameterSyntax.Type != null)
                 {
                     var annotation = new SyntaxAnnotation();
                     var newParameterSyntax = parameterSyntax.WithType(null).WithAdditionalAnnotations(annotation);
 
-                    var oldLambda = node.FirstAncestorOrSelf<ParenthesizedLambdaExpressionSyntax>();
+                    var oldLambda = parameterSyntax.FirstAncestorOrSelf<ParenthesizedLambdaExpressionSyntax>();
                     var newLambda = oldLambda.ReplaceNode(parameterSyntax, newParameterSyntax);
                     var speculationAnalyzer = new SpeculationAnalyzer(oldLambda, newLambda, semanticModel, cancellationToken);
                     newParameterSyntax = (ParameterSyntax)speculationAnalyzer.ReplacedExpression.GetAnnotatedNodesAndTokens(annotation).First();
@@ -54,17 +55,17 @@ private static bool CanRemoveTypeFromParameter(
             return false;
         }
 
-        private static Func<SyntaxNode, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyParameter = SimplifyParameter;
+        private static Func<ParameterSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyParameter = SimplifyParameter;
 
         private static SyntaxNode SimplifyParameter(
-            SyntaxNode node,
+            ParameterSyntax node,
             SemanticModel semanticModel,
             OptionSet optionSet,
             CancellationToken cancellationToken)
         {
             if (CanRemoveTypeFromParameter(node, semanticModel, cancellationToken))
             {
-                var newParameterSyntax = ((ParameterSyntax)node).WithType(null);
+                var newParameterSyntax = node.WithType(null);
                 newParameterSyntax = SimplificationHelpers.CopyAnnotations(node, newParameterSyntax).WithoutAnnotations(Simplifier.Annotation);
                 return newParameterSyntax;
             }
@@ -72,36 +73,71 @@ private static SyntaxNode SimplifyParameter(
             return node;
         }
 
-        private static readonly Func<SyntaxNode, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyParenthesizedLambdaExpression = SimplifyParenthesizedLambdaExpression;
+        private static readonly Func<ParenthesizedLambdaExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyParenthesizedLambdaExpression = SimplifyParenthesizedLambdaExpression;
 
         private static SyntaxNode SimplifyParenthesizedLambdaExpression(
-            SyntaxNode node,
+            ParenthesizedLambdaExpressionSyntax parenthesizedLambda,
             SemanticModel semanticModel,
             OptionSet optionSet,
             CancellationToken cancellationToken)
         {
-            if (node != null && node is ParenthesizedLambdaExpressionSyntax)
+            if (parenthesizedLambda.ParameterList != null &&
+                parenthesizedLambda.ParameterList.Parameters.Count == 1)
             {
-                var parenthesizedLambda = (ParenthesizedLambdaExpressionSyntax)node;
-                if (parenthesizedLambda.ParameterList != null &&
-                    parenthesizedLambda.ParameterList.Parameters.Count == 1)
+                var parameter = parenthesizedLambda.ParameterList.Parameters.First();
+                if (CanRemoveTypeFromParameter(parameter, semanticModel, cancellationToken))
                 {
-                    var parameter = parenthesizedLambda.ParameterList.Parameters.First();
-                    if (CanRemoveTypeFromParameter(parameter, semanticModel, cancellationToken))
-                    {
-                        var newParameterSyntax = parameter.WithType(null);
-                        var newSimpleLambda = SyntaxFactory.SimpleLambdaExpression(
-                            parenthesizedLambda.AsyncKeyword,
-                            newParameterSyntax.WithTrailingTrivia(parenthesizedLambda.ParameterList.GetTrailingTrivia()),
-                            parenthesizedLambda.ArrowToken,
-                            parenthesizedLambda.Body);
-
-                        return SimplificationHelpers.CopyAnnotations(parenthesizedLambda, newSimpleLambda).WithoutAnnotations(Simplifier.Annotation);
-                    }
+                    var newParameterSyntax = parameter.WithType(null);
+                    var newSimpleLambda = SyntaxFactory.SimpleLambdaExpression(
+                        parenthesizedLambda.AsyncKeyword,
+                        newParameterSyntax.WithTrailingTrivia(parenthesizedLambda.ParameterList.GetTrailingTrivia()),
+                        parenthesizedLambda.ArrowToken,
+                        parenthesizedLambda.Body);
+
+                    return SimplificationHelpers.CopyAnnotations(parenthesizedLambda, newSimpleLambda).WithoutAnnotations(Simplifier.Annotation);
                 }
             }
 
+            return parenthesizedLambda;
+        }
+        private static readonly Func<BlockSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyBlock = SimplifyBlock;
+
+        private static SyntaxNode SimplifyBlock(
+            BlockSyntax node,
+            SemanticModel semanticModel,
+            OptionSet optionSet,
+            CancellationToken cancellationToken)
+        {
+            if (node.Statements.Count == 1 &&
+                CanHaveEmbeddedStatement(node.Parent) &&
+                !optionSet.GetOption(CSharpCodeStyleOptions.PreferBraces).Value)
+            {
+                return node.Statements[0];
+            }
+
             return node;
         }
+
+        private static bool CanHaveEmbeddedStatement(SyntaxNode node)
+        {
+            if (node != null)
+            {
+                switch (node.Kind())
+                {
+                    case SyntaxKind.IfStatement:
+                    case SyntaxKind.ElseClause:
+                    case SyntaxKind.ForStatement:
+                    case SyntaxKind.ForEachStatement:
+                    case SyntaxKind.ForEachVariableStatement:
+                    case SyntaxKind.WhileStatement:
+                    case SyntaxKind.DoStatement:
+                    case SyntaxKind.UsingStatement:
+                    case SyntaxKind.LockStatement:
+                        return true;
+                }
+            }
+
+            return false;
+        }
     }
 }
\ No newline at end of file

From 841044b0dfb54d9a1af317bd87cb5710150e6001 Mon Sep 17 00:00:00 2001
From: Neal Gafter <neal@gafter.com>
Date: Wed, 10 May 2017 22:47:56 -0700
Subject: [PATCH 122/284] Share pattern-matching temps when they are the same
 type. (#19378)

Fixes #19280
---
 .../Portable/Binder/PatternSwitchBinder.cs    |   10 +-
 .../Binder/SubsumptionDiagnosticBuilder.cs    |    9 +-
 .../CSharp/Portable/BoundTree/DecisionTree.cs |   30 -
 .../Portable/BoundTree/DecisionTreeBuilder.cs |   50 +-
 .../LocalRewriter_PatternSwitchStatement.cs   |   19 +-
 .../CSharp/Test/Emit/CodeGen/SwitchTests.cs   | 1169 +++++++++++------
 .../CSharp/Test/Emit/PDB/PDBTests.cs          |  292 ++--
 .../Test/ExpressionCompiler/LocalsTests.cs    |  250 ++--
 8 files changed, 1092 insertions(+), 737 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Binder/PatternSwitchBinder.cs b/src/Compilers/CSharp/Portable/Binder/PatternSwitchBinder.cs
index aa86e537ce024..b5551b2f52be0 100644
--- a/src/Compilers/CSharp/Portable/Binder/PatternSwitchBinder.cs
+++ b/src/Compilers/CSharp/Portable/Binder/PatternSwitchBinder.cs
@@ -64,7 +64,7 @@ internal override BoundStatement BindSwitchExpressionAndSections(SwitchStatement
             BoundPatternSwitchLabel defaultLabel;
             bool isComplete;
             ImmutableArray<BoundPatternSwitchSection> switchSections =
-                BindPatternSwitchSections(boundSwitchExpression, node.Sections, originalBinder, out defaultLabel, out isComplete, diagnostics);
+                BindPatternSwitchSections(originalBinder, out defaultLabel, out isComplete, diagnostics);
             var locals = GetDeclaredLocalsForScope(node);
             var functions = GetDeclaredLocalFunctionsForScope(node);
             return new BoundPatternSwitchStatement(
@@ -101,8 +101,6 @@ internal override void BindPatternSwitchLabelForInference(CasePatternSwitchLabel
         /// the decision tree.
         /// </summary>
         private ImmutableArray<BoundPatternSwitchSection> BindPatternSwitchSections(
-            BoundExpression boundSwitchExpression,
-            SyntaxList<SwitchSectionSyntax> sections,
             Binder originalBinder,
             out BoundPatternSwitchLabel defaultLabel,
             out bool isComplete,
@@ -115,11 +113,11 @@ private ImmutableArray<BoundPatternSwitchSection> BindPatternSwitchSections(
 
             // Bind match sections
             var boundPatternSwitchSectionsBuilder = ArrayBuilder<BoundPatternSwitchSection>.GetInstance();
-            SubsumptionDiagnosticBuilder subsumption = new SubsumptionDiagnosticBuilder(ContainingMemberOrLambda, this.Conversions, boundSwitchExpression);
-            foreach (var sectionSyntax in sections)
+            SubsumptionDiagnosticBuilder subsumption = new SubsumptionDiagnosticBuilder(ContainingMemberOrLambda, SwitchSyntax, this.Conversions, SwitchGoverningExpression);
+            foreach (var sectionSyntax in SwitchSyntax.Sections)
             {
                 boundPatternSwitchSectionsBuilder.Add(BindPatternSwitchSection(
-                    boundSwitchExpression, sectionSyntax, originalBinder, ref defaultLabel, ref someValueMatched, subsumption, diagnostics));
+                    SwitchGoverningExpression, sectionSyntax, originalBinder, ref defaultLabel, ref someValueMatched, subsumption, diagnostics));
             }
 
             isComplete = defaultLabel != null || subsumption.IsComplete || someValueMatched;
diff --git a/src/Compilers/CSharp/Portable/Binder/SubsumptionDiagnosticBuilder.cs b/src/Compilers/CSharp/Portable/Binder/SubsumptionDiagnosticBuilder.cs
index f1695a0bda40c..4496196c67e24 100644
--- a/src/Compilers/CSharp/Portable/Binder/SubsumptionDiagnosticBuilder.cs
+++ b/src/Compilers/CSharp/Portable/Binder/SubsumptionDiagnosticBuilder.cs
@@ -20,11 +20,12 @@ internal class SubsumptionDiagnosticBuilder : DecisionTreeBuilder
         private readonly DecisionTree _subsumptionTree;
 
         internal SubsumptionDiagnosticBuilder(Symbol enclosingSymbol,
-                                               Conversions conversions,
-                                               BoundExpression expression)
-            : base(enclosingSymbol, conversions)
+                                              SyntaxNode syntax,
+                                              Conversions conversions,
+                                              BoundExpression expression)
+            : base(enclosingSymbol, syntax, conversions)
         {
-            _subsumptionTree = DecisionTree.Create(expression, expression.Type, enclosingSymbol);
+            _subsumptionTree = CreateEmptyDecisionTree(expression);
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Portable/BoundTree/DecisionTree.cs b/src/Compilers/CSharp/Portable/BoundTree/DecisionTree.cs
index e030bc16cb558..c6d95ca94f611 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/DecisionTree.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/DecisionTree.cs
@@ -78,36 +78,6 @@ public DecisionTree(BoundExpression expression, TypeSymbol type, LocalSymbol tem
             Debug.Assert(this.Type != null);
         }
 
-        /// <summary>
-        /// Create a fresh decision tree for the given input expression of the given type.
-        /// </summary>
-        public static DecisionTree Create(BoundExpression expression, TypeSymbol type, Symbol enclosingSymbol)
-        {
-            Debug.Assert(expression.Type == type);
-            LocalSymbol temp = null;
-            if (expression.ConstantValue == null)
-            {
-                // Unless it is a constant, the decision tree acts on a copy of the input expression.
-                // We create a temp to represent that copy. Lowering will assign into this temp.
-                temp = new SynthesizedLocal(enclosingSymbol as MethodSymbol, type, SynthesizedLocalKind.PatternMatching, expression.Syntax, false, RefKind.None);
-                expression = new BoundLocal(expression.Syntax, temp, null, type);
-            }
-
-            if (type.CanContainNull() || type.SpecialType == SpecialType.None)
-            {
-                // We need the ByType decision tree to separate null from non-null values.
-                // Note that, for the purpose of the decision tree (and subsumption), we
-                // ignore the fact that the input may be a constant, and therefore always
-                // or never null.
-                return new ByType(expression, type, temp);
-            }
-            else
-            {
-                // If it is a (e.g. builtin) value type, we can switch on its (constant) values.
-                return new ByValue(expression, type, temp);
-            }
-        }
-
         /// <summary>
         /// A decision tree node that branches based on (1) whether the input value is null, (2) the runtime
         /// type of the input expression, and finally (3) a default decision tree if nothing in the previous
diff --git a/src/Compilers/CSharp/Portable/BoundTree/DecisionTreeBuilder.cs b/src/Compilers/CSharp/Portable/BoundTree/DecisionTreeBuilder.cs
index 6e72bb9566008..703dffcf48a03 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/DecisionTreeBuilder.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/DecisionTreeBuilder.cs
@@ -26,17 +26,63 @@ internal abstract class DecisionTreeBuilder
         protected readonly Symbol _enclosingSymbol;
         protected readonly Conversions _conversions;
         protected HashSet<DiagnosticInfo> _useSiteDiagnostics = new HashSet<DiagnosticInfo>();
+        private Dictionary<TypeSymbol, LocalSymbol> localByType = new Dictionary<TypeSymbol, LocalSymbol>();
 
         protected DecisionTreeBuilder(
             Symbol enclosingSymbol,
+            SyntaxNode syntax,
             Conversions conversions)
         {
             this._enclosingSymbol = enclosingSymbol;
+            this.Syntax = syntax;
             this._conversions = conversions;
         }
 
         protected SyntaxNode Syntax { private get; set; }
 
+        private LocalSymbol PatternMatchingTemp(TypeSymbol type)
+        {
+            LocalSymbol temp;
+            if (!localByType.TryGetValue(type, out temp))
+            {
+                temp = new SynthesizedLocal(_enclosingSymbol as MethodSymbol, type, SynthesizedLocalKind.PatternMatching, Syntax);
+                localByType.Add(type, temp);
+            }
+
+            return temp;
+        }
+
+        /// <summary>
+        /// Create a fresh decision tree for the given input expression of the given type.
+        /// </summary>
+        protected DecisionTree CreateEmptyDecisionTree(BoundExpression expression)
+        {
+            var type = expression.Type;
+
+            LocalSymbol temp = null;
+            if (expression.ConstantValue == null)
+            {
+                // Unless it is a constant, the decision tree acts on a copy of the input expression.
+                // We create a temp to represent that copy. Lowering will assign into this temp.
+                temp = PatternMatchingTemp(type);
+                expression = new BoundLocal(expression.Syntax, temp, null, type);
+            }
+
+            if (type.CanContainNull() || type.SpecialType == SpecialType.None)
+            {
+                // We need the ByType decision tree to separate null from non-null values.
+                // Note that, for the purpose of the decision tree (and subsumption), we
+                // ignore the fact that the input may be a constant, and therefore always
+                // or never null.
+                return new DecisionTree.ByType(expression, type, temp);
+            }
+            else
+            {
+                // If it is a (e.g. builtin) value type, we can switch on its (constant) values.
+                return new DecisionTree.ByValue(expression, type, temp);
+            }
+        }
+
         protected DecisionTree AddToDecisionTree(DecisionTree decisionTree, SyntaxNode sectionSyntax, BoundPatternSwitchLabel label)
         {
             var pattern = label.Pattern;
@@ -237,7 +283,7 @@ private DecisionTree AddByValue(DecisionTree.ByType byType, BoundConstantPattern
             if (forType == null)
             {
                 var type = value.Value.Type;
-                var localSymbol = new SynthesizedLocal(_enclosingSymbol as MethodSymbol, type, SynthesizedLocalKind.PatternMatching, Syntax, false, RefKind.None);
+                var localSymbol = PatternMatchingTemp(type);
                 var narrowedExpression = new BoundLocal(Syntax, localSymbol, null, type);
                 forType = new DecisionTree.ByValue(narrowedExpression, value.Value.Type.TupleUnderlyingTypeOrSelf(), localSymbol);
                 byType.TypeAndDecision.Add(new KeyValuePair<TypeSymbol, DecisionTree>(value.Value.Type, forType));
@@ -338,7 +384,7 @@ private DecisionTree AddByType(DecisionTree.ByType byType, TypeSymbol type, Deci
 
             if (result == null)
             {
-                var localSymbol = new SynthesizedLocal(_enclosingSymbol as MethodSymbol, type, SynthesizedLocalKind.PatternMatching, Syntax, false, RefKind.None);
+                var localSymbol = PatternMatchingTemp(type);
                 var expression = new BoundLocal(Syntax, localSymbol, null, type);
                 result = makeDecision(expression, type);
                 Debug.Assert(result.Temp == null);
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs
index f54cbd709d3bb..c8f353222bbab 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs
@@ -38,7 +38,7 @@ private class PatternSwitchLocalRewriter : DecisionTreeBuilder
             private ArrayBuilder<BoundStatement> _loweredDecisionTree = ArrayBuilder<BoundStatement>.GetInstance();
 
             private PatternSwitchLocalRewriter(LocalRewriter localRewriter, BoundPatternSwitchStatement node)
-                : base(localRewriter._factory.CurrentMethod, localRewriter._factory.Compilation.Conversions)
+                : base(localRewriter._factory.CurrentMethod, node.Syntax, localRewriter._factory.Compilation.Conversions)
             {
                 this._localRewriter = localRewriter;
                 this._factory = localRewriter._factory;
@@ -59,15 +59,9 @@ private BoundStatement MakeLoweredForm(BoundPatternSwitchStatement node)
                 var expression = _localRewriter.VisitExpression(node.Expression);
                 var result = ArrayBuilder<BoundStatement>.GetInstance();
 
-                // if the expression is "too complex", we copy it to a temp.
-                LocalSymbol initialTemp = null;
                 if (expression.ConstantValue == null)
                 {
-                    initialTemp = _factory.SynthesizedLocal(expression.Type, expression.Syntax);
-                    result.Add(_factory.Assignment(_factory.Local(initialTemp), expression));
-                    expression = _factory.Local(initialTemp);
-
-                    // EnC: We need to insert a hidden sequence point to handle function remapping in case 
+                    // EnC: We need to insert a hidden sequence point to handle function remapping in case
                     // the containing method is edited while methods invoked in the expression are being executed.
                     if (!node.WasCompilerGenerated && _localRewriter.Instrument)
                     {
@@ -85,7 +79,6 @@ private BoundStatement MakeLoweredForm(BoundPatternSwitchStatement node)
                 }
                 // at this point the end of result is unreachable.
 
-                _declaredTemps.AddOptional(initialTemp);
                 _declaredTemps.AddRange(node.InnerLocals);
 
                 // output the sections of code
@@ -148,7 +141,7 @@ private DecisionTree LowerToDecisionTree(
                 BoundExpression loweredExpression,
                 BoundPatternSwitchStatement node)
             {
-                var loweredDecisionTree = DecisionTree.Create(loweredExpression, loweredExpression.Type, _enclosingSymbol);
+                var loweredDecisionTree = CreateEmptyDecisionTree(loweredExpression);
                 BoundPatternSwitchLabel defaultLabel = null;
                 SyntaxNode defaultSection = null;
                 foreach (var section in node.SwitchSections)
@@ -223,15 +216,11 @@ private void LowerDecisionTree(BoundExpression expression, DecisionTree decision
                         _loweredDecisionTree.Add(_factory.Assignment(decisionTree.Expression, convertedExpression));
                     }
 
+                    // If the temp is not yet in the declared temp set, add it now
                     if (_declaredTempSet.Add(decisionTree.Temp))
                     {
                         _declaredTemps.Add(decisionTree.Temp);
                     }
-                    else
-                    {
-                        // we should only attempt to declare each temp once.
-                        throw ExceptionUtilities.Unreachable;
-                    }
                 }
 
                 switch (decisionTree.Kind)
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs
index 39c1c7f56c87b..3472ef5b26ed6 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs
@@ -7735,46 +7735,43 @@ .locals init (int? V_0,
                 expectedOutput: "null1");
             compVerifier.VerifyIL("Program.M",
 @"{
-  // Code size       69 (0x45)
+  // Code size       65 (0x41)
   .maxstack  1
   .locals init (int? V_0,
                 int V_1,
-                int? V_2,
-                int V_3, //i
-                int? V_4,
-                int? V_5)
+                int V_2, //i
+                int? V_3,
+                int? V_4)
   IL_0000:  nop
   IL_0001:  ldarg.0
-  IL_0002:  stloc.2
-  IL_0003:  ldloc.2
-  IL_0004:  stloc.s    V_4
-  IL_0006:  ldloc.s    V_4
-  IL_0008:  stloc.0
-  IL_0009:  ldloca.s   V_0
-  IL_000b:  call       ""bool int?.HasValue.get""
-  IL_0010:  brtrue.s   IL_0014
-  IL_0012:  br.s       IL_0037
-  IL_0014:  ldloc.0
-  IL_0015:  stloc.s    V_5
-  IL_0017:  ldloca.s   V_5
-  IL_0019:  call       ""int int?.GetValueOrDefault()""
-  IL_001e:  stloc.1
-  IL_001f:  ldloca.s   V_5
-  IL_0021:  call       ""bool int?.HasValue.get""
-  IL_0026:  brfalse.s  IL_002a
+  IL_0002:  stloc.3
+  IL_0003:  ldloc.3
+  IL_0004:  stloc.0
+  IL_0005:  ldloca.s   V_0
+  IL_0007:  call       ""bool int?.HasValue.get""
+  IL_000c:  brtrue.s   IL_0010
+  IL_000e:  br.s       IL_0033
+  IL_0010:  ldloc.0
+  IL_0011:  stloc.s    V_4
+  IL_0013:  ldloca.s   V_4
+  IL_0015:  call       ""int int?.GetValueOrDefault()""
+  IL_001a:  stloc.1
+  IL_001b:  ldloca.s   V_4
+  IL_001d:  call       ""bool int?.HasValue.get""
+  IL_0022:  brfalse.s  IL_0026
+  IL_0024:  br.s       IL_0026
+  IL_0026:  ldloc.1
+  IL_0027:  stloc.2
   IL_0028:  br.s       IL_002a
-  IL_002a:  ldloc.1
-  IL_002b:  stloc.3
-  IL_002c:  br.s       IL_002e
-  IL_002e:  ldloc.3
-  IL_002f:  call       ""void System.Console.Write(int)""
-  IL_0034:  nop
-  IL_0035:  br.s       IL_0044
-  IL_0037:  ldstr      ""null""
-  IL_003c:  call       ""void System.Console.Write(string)""
-  IL_0041:  nop
-  IL_0042:  br.s       IL_0044
-  IL_0044:  ret
+  IL_002a:  ldloc.2
+  IL_002b:  call       ""void System.Console.Write(int)""
+  IL_0030:  nop
+  IL_0031:  br.s       IL_0040
+  IL_0033:  ldstr      ""null""
+  IL_0038:  call       ""void System.Console.Write(string)""
+  IL_003d:  nop
+  IL_003e:  br.s       IL_0040
+  IL_0040:  ret
 }"
             );
         }
@@ -7821,32 +7818,29 @@ .locals init (System.IComparable V_0)
                 expectedOutput: "1");
             compVerifier.VerifyIL("Program.M",
 @"{
-  // Code size       32 (0x20)
+  // Code size       28 (0x1c)
   .maxstack  1
   .locals init (int V_0,
                 System.IComparable V_1,
-                int V_2,
-                System.IComparable V_3, //i
-                int V_4)
+                System.IComparable V_2, //i
+                int V_3)
   IL_0000:  nop
   IL_0001:  ldarg.0
-  IL_0002:  stloc.2
-  IL_0003:  ldloc.2
-  IL_0004:  stloc.s    V_4
-  IL_0006:  ldloc.s    V_4
-  IL_0008:  stloc.0
-  IL_0009:  ldloc.0
-  IL_000a:  box        ""int""
-  IL_000f:  stloc.1
+  IL_0002:  stloc.3
+  IL_0003:  ldloc.3
+  IL_0004:  stloc.0
+  IL_0005:  ldloc.0
+  IL_0006:  box        ""int""
+  IL_000b:  stloc.1
+  IL_000c:  br.s       IL_000e
+  IL_000e:  ldloc.1
+  IL_000f:  stloc.2
   IL_0010:  br.s       IL_0012
-  IL_0012:  ldloc.1
-  IL_0013:  stloc.3
-  IL_0014:  br.s       IL_0016
-  IL_0016:  ldloc.3
-  IL_0017:  call       ""void System.Console.Write(object)""
-  IL_001c:  nop
-  IL_001d:  br.s       IL_001f
-  IL_001f:  ret
+  IL_0012:  ldloc.2
+  IL_0013:  call       ""void System.Console.Write(object)""
+  IL_0018:  nop
+  IL_0019:  br.s       IL_001b
+  IL_001b:  ret
 }"
             );
         }
@@ -7900,37 +7894,34 @@ .locals init (int? V_0,
                 expectedOutput: "1");
             compVerifier.VerifyIL("Program.M",
 @"{
-  // Code size       45 (0x2d)
+  // Code size       41 (0x29)
   .maxstack  1
   .locals init (int? V_0,
                 System.IComparable V_1,
-                int? V_2,
-                System.IComparable V_3, //i
-                int? V_4)
+                System.IComparable V_2, //i
+                int? V_3)
   IL_0000:  nop
   IL_0001:  ldarg.0
-  IL_0002:  stloc.2
-  IL_0003:  ldloc.2
-  IL_0004:  stloc.s    V_4
-  IL_0006:  ldloc.s    V_4
-  IL_0008:  stloc.0
-  IL_0009:  ldloca.s   V_0
-  IL_000b:  call       ""bool int?.HasValue.get""
-  IL_0010:  brtrue.s   IL_0014
-  IL_0012:  br.s       IL_001d
-  IL_0014:  ldloc.0
-  IL_0015:  box        ""int?""
-  IL_001a:  stloc.1
-  IL_001b:  br.s       IL_001f
-  IL_001d:  br.s       IL_002c
-  IL_001f:  ldloc.1
-  IL_0020:  stloc.3
-  IL_0021:  br.s       IL_0023
-  IL_0023:  ldloc.3
-  IL_0024:  call       ""void System.Console.Write(object)""
-  IL_0029:  nop
-  IL_002a:  br.s       IL_002c
-  IL_002c:  ret
+  IL_0002:  stloc.3
+  IL_0003:  ldloc.3
+  IL_0004:  stloc.0
+  IL_0005:  ldloca.s   V_0
+  IL_0007:  call       ""bool int?.HasValue.get""
+  IL_000c:  brtrue.s   IL_0010
+  IL_000e:  br.s       IL_0019
+  IL_0010:  ldloc.0
+  IL_0011:  box        ""int?""
+  IL_0016:  stloc.1
+  IL_0017:  br.s       IL_001b
+  IL_0019:  br.s       IL_0028
+  IL_001b:  ldloc.1
+  IL_001c:  stloc.2
+  IL_001d:  br.s       IL_001f
+  IL_001f:  ldloc.2
+  IL_0020:  call       ""void System.Console.Write(object)""
+  IL_0025:  nop
+  IL_0026:  br.s       IL_0028
+  IL_0028:  ret
 }"
             );
         }
@@ -7992,44 +7983,41 @@ .locals init (object V_0,
                 expectedOutput: "1");
             compVerifier.VerifyIL("Program.M",
 @"{
-  // Code size       62 (0x3e)
+  // Code size       58 (0x3a)
   .maxstack  1
   .locals init (object V_0,
                 int V_1,
-                object V_2,
-                int V_3, //i
-                object V_4,
-                int? V_5)
+                int V_2, //i
+                object V_3,
+                int? V_4)
   IL_0000:  nop
   IL_0001:  ldarg.0
-  IL_0002:  stloc.2
-  IL_0003:  ldloc.2
-  IL_0004:  stloc.s    V_4
-  IL_0006:  ldloc.s    V_4
-  IL_0008:  stloc.0
-  IL_0009:  ldloc.0
-  IL_000a:  brtrue.s   IL_000e
-  IL_000c:  br.s       IL_002e
-  IL_000e:  ldloc.0
-  IL_000f:  isinst     ""int?""
-  IL_0014:  unbox.any  ""int?""
-  IL_0019:  stloc.s    V_5
-  IL_001b:  ldloca.s   V_5
-  IL_001d:  call       ""int int?.GetValueOrDefault()""
-  IL_0022:  stloc.1
-  IL_0023:  ldloca.s   V_5
-  IL_0025:  call       ""bool int?.HasValue.get""
-  IL_002a:  brfalse.s  IL_002e
-  IL_002c:  br.s       IL_0030
-  IL_002e:  br.s       IL_003d
-  IL_0030:  ldloc.1
-  IL_0031:  stloc.3
-  IL_0032:  br.s       IL_0034
-  IL_0034:  ldloc.3
-  IL_0035:  call       ""void System.Console.Write(int)""
-  IL_003a:  nop
-  IL_003b:  br.s       IL_003d
-  IL_003d:  ret
+  IL_0002:  stloc.3
+  IL_0003:  ldloc.3
+  IL_0004:  stloc.0
+  IL_0005:  ldloc.0
+  IL_0006:  brtrue.s   IL_000a
+  IL_0008:  br.s       IL_002a
+  IL_000a:  ldloc.0
+  IL_000b:  isinst     ""int?""
+  IL_0010:  unbox.any  ""int?""
+  IL_0015:  stloc.s    V_4
+  IL_0017:  ldloca.s   V_4
+  IL_0019:  call       ""int int?.GetValueOrDefault()""
+  IL_001e:  stloc.1
+  IL_001f:  ldloca.s   V_4
+  IL_0021:  call       ""bool int?.HasValue.get""
+  IL_0026:  brfalse.s  IL_002a
+  IL_0028:  br.s       IL_002c
+  IL_002a:  br.s       IL_0039
+  IL_002c:  ldloc.1
+  IL_002d:  stloc.2
+  IL_002e:  br.s       IL_0030
+  IL_0030:  ldloc.2
+  IL_0031:  call       ""void System.Console.Write(int)""
+  IL_0036:  nop
+  IL_0037:  br.s       IL_0039
+  IL_0039:  ret
 }"
             );
         }
@@ -8101,52 +8089,49 @@ .locals init (object V_0,
                 expectedOutput: "1");
             compVerifier.VerifyIL("Program.M<T>",
 @"{
-  // Code size       75 (0x4b)
+  // Code size       71 (0x47)
   .maxstack  2
   .locals init (object V_0,
                 T V_1,
-                object V_2,
-                T V_3, //i
+                T V_2, //i
+                object V_3,
                 object V_4,
-                object V_5,
-                T V_6)
+                T V_5)
   IL_0000:  nop
   IL_0001:  ldarg.0
-  IL_0002:  stloc.2
-  IL_0003:  ldloc.2
-  IL_0004:  stloc.s    V_4
-  IL_0006:  ldloc.s    V_4
-  IL_0008:  stloc.0
-  IL_0009:  ldloc.0
-  IL_000a:  brtrue.s   IL_000e
-  IL_000c:  br.s       IL_0036
-  IL_000e:  ldloc.0
-  IL_000f:  stloc.s    V_5
-  IL_0011:  ldloc.s    V_5
-  IL_0013:  isinst     ""T""
-  IL_0018:  ldnull
-  IL_0019:  cgt.un
-  IL_001b:  dup
-  IL_001c:  brtrue.s   IL_002a
-  IL_001e:  ldloca.s   V_6
-  IL_0020:  initobj    ""T""
-  IL_0026:  ldloc.s    V_6
-  IL_0028:  br.s       IL_0031
-  IL_002a:  ldloc.s    V_5
-  IL_002c:  unbox.any  ""T""
-  IL_0031:  stloc.1
-  IL_0032:  brfalse.s  IL_0036
-  IL_0034:  br.s       IL_0038
-  IL_0036:  br.s       IL_004a
-  IL_0038:  ldloc.1
-  IL_0039:  stloc.3
-  IL_003a:  br.s       IL_003c
-  IL_003c:  ldloc.3
-  IL_003d:  box        ""T""
-  IL_0042:  call       ""void System.Console.Write(object)""
-  IL_0047:  nop
-  IL_0048:  br.s       IL_004a
-  IL_004a:  ret
+  IL_0002:  stloc.3
+  IL_0003:  ldloc.3
+  IL_0004:  stloc.0
+  IL_0005:  ldloc.0
+  IL_0006:  brtrue.s   IL_000a
+  IL_0008:  br.s       IL_0032
+  IL_000a:  ldloc.0
+  IL_000b:  stloc.s    V_4
+  IL_000d:  ldloc.s    V_4
+  IL_000f:  isinst     ""T""
+  IL_0014:  ldnull
+  IL_0015:  cgt.un
+  IL_0017:  dup
+  IL_0018:  brtrue.s   IL_0026
+  IL_001a:  ldloca.s   V_5
+  IL_001c:  initobj    ""T""
+  IL_0022:  ldloc.s    V_5
+  IL_0024:  br.s       IL_002d
+  IL_0026:  ldloc.s    V_4
+  IL_0028:  unbox.any  ""T""
+  IL_002d:  stloc.1
+  IL_002e:  brfalse.s  IL_0032
+  IL_0030:  br.s       IL_0034
+  IL_0032:  br.s       IL_0046
+  IL_0034:  ldloc.1
+  IL_0035:  stloc.2
+  IL_0036:  br.s       IL_0038
+  IL_0038:  ldloc.2
+  IL_0039:  box        ""T""
+  IL_003e:  call       ""void System.Console.Write(object)""
+  IL_0043:  nop
+  IL_0044:  br.s       IL_0046
+  IL_0046:  ret
 }"
             );
         }
@@ -8218,52 +8203,49 @@ .locals init (System.IComparable V_0,
                 expectedOutput: "1");
             compVerifier.VerifyIL("Program.M<T>",
 @"{
-  // Code size       75 (0x4b)
+  // Code size       71 (0x47)
   .maxstack  2
   .locals init (System.IComparable V_0,
                 T V_1,
-                System.IComparable V_2,
-                T V_3, //i
-                System.IComparable V_4,
-                object V_5,
-                T V_6)
+                T V_2, //i
+                System.IComparable V_3,
+                object V_4,
+                T V_5)
   IL_0000:  nop
   IL_0001:  ldarg.0
-  IL_0002:  stloc.2
-  IL_0003:  ldloc.2
-  IL_0004:  stloc.s    V_4
-  IL_0006:  ldloc.s    V_4
-  IL_0008:  stloc.0
-  IL_0009:  ldloc.0
-  IL_000a:  brtrue.s   IL_000e
-  IL_000c:  br.s       IL_0036
-  IL_000e:  ldloc.0
-  IL_000f:  stloc.s    V_5
-  IL_0011:  ldloc.s    V_5
-  IL_0013:  isinst     ""T""
-  IL_0018:  ldnull
-  IL_0019:  cgt.un
-  IL_001b:  dup
-  IL_001c:  brtrue.s   IL_002a
-  IL_001e:  ldloca.s   V_6
-  IL_0020:  initobj    ""T""
-  IL_0026:  ldloc.s    V_6
-  IL_0028:  br.s       IL_0031
-  IL_002a:  ldloc.s    V_5
-  IL_002c:  unbox.any  ""T""
-  IL_0031:  stloc.1
-  IL_0032:  brfalse.s  IL_0036
-  IL_0034:  br.s       IL_0038
-  IL_0036:  br.s       IL_004a
-  IL_0038:  ldloc.1
-  IL_0039:  stloc.3
-  IL_003a:  br.s       IL_003c
-  IL_003c:  ldloc.3
-  IL_003d:  box        ""T""
-  IL_0042:  call       ""void System.Console.Write(object)""
-  IL_0047:  nop
-  IL_0048:  br.s       IL_004a
-  IL_004a:  ret
+  IL_0002:  stloc.3
+  IL_0003:  ldloc.3
+  IL_0004:  stloc.0
+  IL_0005:  ldloc.0
+  IL_0006:  brtrue.s   IL_000a
+  IL_0008:  br.s       IL_0032
+  IL_000a:  ldloc.0
+  IL_000b:  stloc.s    V_4
+  IL_000d:  ldloc.s    V_4
+  IL_000f:  isinst     ""T""
+  IL_0014:  ldnull
+  IL_0015:  cgt.un
+  IL_0017:  dup
+  IL_0018:  brtrue.s   IL_0026
+  IL_001a:  ldloca.s   V_5
+  IL_001c:  initobj    ""T""
+  IL_0022:  ldloc.s    V_5
+  IL_0024:  br.s       IL_002d
+  IL_0026:  ldloc.s    V_4
+  IL_0028:  unbox.any  ""T""
+  IL_002d:  stloc.1
+  IL_002e:  brfalse.s  IL_0032
+  IL_0030:  br.s       IL_0034
+  IL_0032:  br.s       IL_0046
+  IL_0034:  ldloc.1
+  IL_0035:  stloc.2
+  IL_0036:  br.s       IL_0038
+  IL_0038:  ldloc.2
+  IL_0039:  box        ""T""
+  IL_003e:  call       ""void System.Console.Write(object)""
+  IL_0043:  nop
+  IL_0044:  br.s       IL_0046
+  IL_0046:  ret
 }"
             );
         }
@@ -8337,54 +8319,51 @@ .locals init (U V_0,
                 expectedOutput: "1");
             compVerifier.VerifyIL("Program.M<T, U>",
 @"{
-  // Code size       85 (0x55)
+  // Code size       81 (0x51)
   .maxstack  2
   .locals init (U V_0,
                 T V_1,
-                U V_2,
-                T V_3, //i
-                U V_4,
-                object V_5,
-                T V_6)
+                T V_2, //i
+                U V_3,
+                object V_4,
+                T V_5)
   IL_0000:  nop
   IL_0001:  ldarg.0
-  IL_0002:  stloc.2
-  IL_0003:  ldloc.2
-  IL_0004:  stloc.s    V_4
-  IL_0006:  ldloc.s    V_4
-  IL_0008:  stloc.0
-  IL_0009:  ldloc.0
-  IL_000a:  box        ""U""
-  IL_000f:  brtrue.s   IL_0013
-  IL_0011:  br.s       IL_0040
-  IL_0013:  ldloc.0
-  IL_0014:  box        ""U""
-  IL_0019:  stloc.s    V_5
-  IL_001b:  ldloc.s    V_5
-  IL_001d:  isinst     ""T""
-  IL_0022:  ldnull
-  IL_0023:  cgt.un
-  IL_0025:  dup
-  IL_0026:  brtrue.s   IL_0034
-  IL_0028:  ldloca.s   V_6
-  IL_002a:  initobj    ""T""
-  IL_0030:  ldloc.s    V_6
-  IL_0032:  br.s       IL_003b
-  IL_0034:  ldloc.s    V_5
-  IL_0036:  unbox.any  ""T""
-  IL_003b:  stloc.1
-  IL_003c:  brfalse.s  IL_0040
-  IL_003e:  br.s       IL_0042
-  IL_0040:  br.s       IL_0054
-  IL_0042:  ldloc.1
-  IL_0043:  stloc.3
-  IL_0044:  br.s       IL_0046
-  IL_0046:  ldloc.3
-  IL_0047:  box        ""T""
-  IL_004c:  call       ""void System.Console.Write(object)""
-  IL_0051:  nop
-  IL_0052:  br.s       IL_0054
-  IL_0054:  ret
+  IL_0002:  stloc.3
+  IL_0003:  ldloc.3
+  IL_0004:  stloc.0
+  IL_0005:  ldloc.0
+  IL_0006:  box        ""U""
+  IL_000b:  brtrue.s   IL_000f
+  IL_000d:  br.s       IL_003c
+  IL_000f:  ldloc.0
+  IL_0010:  box        ""U""
+  IL_0015:  stloc.s    V_4
+  IL_0017:  ldloc.s    V_4
+  IL_0019:  isinst     ""T""
+  IL_001e:  ldnull
+  IL_001f:  cgt.un
+  IL_0021:  dup
+  IL_0022:  brtrue.s   IL_0030
+  IL_0024:  ldloca.s   V_5
+  IL_0026:  initobj    ""T""
+  IL_002c:  ldloc.s    V_5
+  IL_002e:  br.s       IL_0037
+  IL_0030:  ldloc.s    V_4
+  IL_0032:  unbox.any  ""T""
+  IL_0037:  stloc.1
+  IL_0038:  brfalse.s  IL_003c
+  IL_003a:  br.s       IL_003e
+  IL_003c:  br.s       IL_0050
+  IL_003e:  ldloc.1
+  IL_003f:  stloc.2
+  IL_0040:  br.s       IL_0042
+  IL_0042:  ldloc.2
+  IL_0043:  box        ""T""
+  IL_0048:  call       ""void System.Console.Write(object)""
+  IL_004d:  nop
+  IL_004e:  br.s       IL_0050
+  IL_0050:  ret
 }"
             );
         }
@@ -8598,57 +8577,54 @@ .locals init (T V_0, //t
             );
             compVerifier.VerifyIL("Program.M2<T>",
 @"{
-  // Code size       82 (0x52)
+  // Code size       78 (0x4e)
   .maxstack  2
   .locals init (System.ValueType V_0,
                 T V_1,
-                System.ValueType V_2,
-                T V_3, //t
-                System.ValueType V_4,
-                object V_5,
-                T V_6,
-                T V_7)
+                T V_2, //t
+                System.ValueType V_3,
+                object V_4,
+                T V_5,
+                T V_6)
   IL_0000:  nop
   IL_0001:  ldarg.0
-  IL_0002:  stloc.2
-  IL_0003:  ldloc.2
-  IL_0004:  stloc.s    V_4
-  IL_0006:  ldloc.s    V_4
-  IL_0008:  stloc.0
-  IL_0009:  ldloc.0
-  IL_000a:  brtrue.s   IL_000e
-  IL_000c:  br.s       IL_0036
-  IL_000e:  ldloc.0
-  IL_000f:  stloc.s    V_5
-  IL_0011:  ldloc.s    V_5
-  IL_0013:  isinst     ""T""
-  IL_0018:  ldnull
-  IL_0019:  cgt.un
-  IL_001b:  dup
-  IL_001c:  brtrue.s   IL_002a
-  IL_001e:  ldloca.s   V_6
-  IL_0020:  initobj    ""T""
-  IL_0026:  ldloc.s    V_6
-  IL_0028:  br.s       IL_0031
-  IL_002a:  ldloc.s    V_5
-  IL_002c:  unbox.any  ""T""
-  IL_0031:  stloc.1
-  IL_0032:  brfalse.s  IL_0036
-  IL_0034:  br.s       IL_0038
-  IL_0036:  br.s       IL_0041
-  IL_0038:  ldloc.1
-  IL_0039:  stloc.3
-  IL_003a:  br.s       IL_003c
-  IL_003c:  ldloc.3
-  IL_003d:  stloc.s    V_7
-  IL_003f:  br.s       IL_004f
-  IL_0041:  ldloca.s   V_6
-  IL_0043:  initobj    ""T""
-  IL_0049:  ldloc.s    V_6
-  IL_004b:  stloc.s    V_7
-  IL_004d:  br.s       IL_004f
-  IL_004f:  ldloc.s    V_7
-  IL_0051:  ret
+  IL_0002:  stloc.3
+  IL_0003:  ldloc.3
+  IL_0004:  stloc.0
+  IL_0005:  ldloc.0
+  IL_0006:  brtrue.s   IL_000a
+  IL_0008:  br.s       IL_0032
+  IL_000a:  ldloc.0
+  IL_000b:  stloc.s    V_4
+  IL_000d:  ldloc.s    V_4
+  IL_000f:  isinst     ""T""
+  IL_0014:  ldnull
+  IL_0015:  cgt.un
+  IL_0017:  dup
+  IL_0018:  brtrue.s   IL_0026
+  IL_001a:  ldloca.s   V_5
+  IL_001c:  initobj    ""T""
+  IL_0022:  ldloc.s    V_5
+  IL_0024:  br.s       IL_002d
+  IL_0026:  ldloc.s    V_4
+  IL_0028:  unbox.any  ""T""
+  IL_002d:  stloc.1
+  IL_002e:  brfalse.s  IL_0032
+  IL_0030:  br.s       IL_0034
+  IL_0032:  br.s       IL_003d
+  IL_0034:  ldloc.1
+  IL_0035:  stloc.2
+  IL_0036:  br.s       IL_0038
+  IL_0038:  ldloc.2
+  IL_0039:  stloc.s    V_6
+  IL_003b:  br.s       IL_004b
+  IL_003d:  ldloca.s   V_5
+  IL_003f:  initobj    ""T""
+  IL_0045:  ldloc.s    V_5
+  IL_0047:  stloc.s    V_6
+  IL_0049:  br.s       IL_004b
+  IL_004b:  ldloc.s    V_6
+  IL_004d:  ret
 }"
             );
         }
@@ -8780,50 +8756,47 @@ .locals init (int V_0, //t
             );
             compVerifier.VerifyIL("Program.M2<T>",
 @"{
-  // Code size       75 (0x4b)
+  // Code size       71 (0x47)
   .maxstack  1
   .locals init (T V_0,
                 int V_1,
-                T V_2,
-                int V_3, //t
-                T V_4,
-                int? V_5,
-                int V_6)
+                int V_2, //t
+                T V_3,
+                int? V_4,
+                int V_5)
   IL_0000:  nop
   IL_0001:  ldarg.0
-  IL_0002:  stloc.2
-  IL_0003:  ldloc.2
-  IL_0004:  stloc.s    V_4
-  IL_0006:  ldloc.s    V_4
-  IL_0008:  stloc.0
-  IL_0009:  ldloc.0
-  IL_000a:  box        ""T""
-  IL_000f:  brtrue.s   IL_0013
-  IL_0011:  br.s       IL_0038
-  IL_0013:  ldloc.0
-  IL_0014:  box        ""T""
-  IL_0019:  isinst     ""int?""
-  IL_001e:  unbox.any  ""int?""
-  IL_0023:  stloc.s    V_5
-  IL_0025:  ldloca.s   V_5
-  IL_0027:  call       ""int int?.GetValueOrDefault()""
-  IL_002c:  stloc.1
-  IL_002d:  ldloca.s   V_5
-  IL_002f:  call       ""bool int?.HasValue.get""
-  IL_0034:  brfalse.s  IL_0038
-  IL_0036:  br.s       IL_003a
-  IL_0038:  br.s       IL_0043
-  IL_003a:  ldloc.1
-  IL_003b:  stloc.3
-  IL_003c:  br.s       IL_003e
-  IL_003e:  ldloc.3
-  IL_003f:  stloc.s    V_6
-  IL_0041:  br.s       IL_0048
-  IL_0043:  ldc.i4.0
-  IL_0044:  stloc.s    V_6
-  IL_0046:  br.s       IL_0048
-  IL_0048:  ldloc.s    V_6
-  IL_004a:  ret
+  IL_0002:  stloc.3
+  IL_0003:  ldloc.3
+  IL_0004:  stloc.0
+  IL_0005:  ldloc.0
+  IL_0006:  box        ""T""
+  IL_000b:  brtrue.s   IL_000f
+  IL_000d:  br.s       IL_0034
+  IL_000f:  ldloc.0
+  IL_0010:  box        ""T""
+  IL_0015:  isinst     ""int?""
+  IL_001a:  unbox.any  ""int?""
+  IL_001f:  stloc.s    V_4
+  IL_0021:  ldloca.s   V_4
+  IL_0023:  call       ""int int?.GetValueOrDefault()""
+  IL_0028:  stloc.1
+  IL_0029:  ldloca.s   V_4
+  IL_002b:  call       ""bool int?.HasValue.get""
+  IL_0030:  brfalse.s  IL_0034
+  IL_0032:  br.s       IL_0036
+  IL_0034:  br.s       IL_003f
+  IL_0036:  ldloc.1
+  IL_0037:  stloc.2
+  IL_0038:  br.s       IL_003a
+  IL_003a:  ldloc.2
+  IL_003b:  stloc.s    V_5
+  IL_003d:  br.s       IL_0044
+  IL_003f:  ldc.i4.0
+  IL_0040:  stloc.s    V_5
+  IL_0042:  br.s       IL_0044
+  IL_0044:  ldloc.s    V_5
+  IL_0046:  ret
 }"
             );
         }
@@ -9125,81 +9098,497 @@ public static string M2(object o)
             compVerifier.VerifyDiagnostics();
             compVerifier.VerifyIL("Program.M2",
 @"{
-  // Code size      154 (0x9a)
+  // Code size      150 (0x96)
   .maxstack  2
   .locals init (object V_0,
                 Generic<long>.Color V_1,
                 Generic<object>.Color V_2,
-                object V_3,
-                Generic<long>.Color V_4, //c
-                object V_5,
-                Generic<long>.Color? V_6,
-                Generic<object>.Color? V_7,
-                int V_8,
-                string V_9)
+                Generic<long>.Color V_3, //c
+                object V_4,
+                Generic<long>.Color? V_5,
+                Generic<object>.Color? V_6,
+                int V_7,
+                string V_8)
   IL_0000:  nop
   IL_0001:  ldarg.0
-  IL_0002:  stloc.3
-  IL_0003:  ldloc.3
-  IL_0004:  stloc.s    V_5
-  IL_0006:  ldloc.s    V_5
-  IL_0008:  stloc.0
-  IL_0009:  ldloc.0
-  IL_000a:  brtrue.s   IL_000e
-  IL_000c:  br.s       IL_0060
-  IL_000e:  ldloc.0
-  IL_000f:  isinst     ""Generic<long>.Color?""
-  IL_0014:  unbox.any  ""Generic<long>.Color?""
-  IL_0019:  stloc.s    V_6
-  IL_001b:  ldloca.s   V_6
-  IL_001d:  call       ""Generic<long>.Color Generic<long>.Color?.GetValueOrDefault()""
-  IL_0022:  stloc.1
-  IL_0023:  ldloca.s   V_6
-  IL_0025:  call       ""bool Generic<long>.Color?.HasValue.get""
-  IL_002a:  brfalse.s  IL_002e
-  IL_002c:  br.s       IL_0062
-  IL_002e:  ldloc.0
-  IL_002f:  isinst     ""Generic<object>.Color?""
-  IL_0034:  unbox.any  ""Generic<object>.Color?""
-  IL_0039:  stloc.s    V_7
-  IL_003b:  ldloca.s   V_7
-  IL_003d:  call       ""Generic<object>.Color Generic<object>.Color?.GetValueOrDefault()""
-  IL_0042:  stloc.2
+  IL_0002:  stloc.s    V_4
+  IL_0004:  ldloc.s    V_4
+  IL_0006:  stloc.0
+  IL_0007:  ldloc.0
+  IL_0008:  brtrue.s   IL_000c
+  IL_000a:  br.s       IL_005e
+  IL_000c:  ldloc.0
+  IL_000d:  isinst     ""Generic<long>.Color?""
+  IL_0012:  unbox.any  ""Generic<long>.Color?""
+  IL_0017:  stloc.s    V_5
+  IL_0019:  ldloca.s   V_5
+  IL_001b:  call       ""Generic<long>.Color Generic<long>.Color?.GetValueOrDefault()""
+  IL_0020:  stloc.1
+  IL_0021:  ldloca.s   V_5
+  IL_0023:  call       ""bool Generic<long>.Color?.HasValue.get""
+  IL_0028:  brfalse.s  IL_002c
+  IL_002a:  br.s       IL_0060
+  IL_002c:  ldloc.0
+  IL_002d:  isinst     ""Generic<object>.Color?""
+  IL_0032:  unbox.any  ""Generic<object>.Color?""
+  IL_0037:  stloc.s    V_6
+  IL_0039:  ldloca.s   V_6
+  IL_003b:  call       ""Generic<object>.Color Generic<object>.Color?.GetValueOrDefault()""
+  IL_0040:  stloc.2
+  IL_0041:  ldloca.s   V_6
+  IL_0043:  call       ""bool Generic<object>.Color?.HasValue.get""
+  IL_0048:  brfalse.s  IL_005e
+  IL_004a:  ldloc.2
+  IL_004b:  stloc.s    V_7
+  IL_004d:  ldloc.s    V_7
+  IL_004f:  brfalse.s  IL_005a
+  IL_0051:  br.s       IL_0053
+  IL_0053:  ldloc.s    V_7
+  IL_0055:  ldc.i4.1
+  IL_0056:  beq.s      IL_005c
+  IL_0058:  br.s       IL_005e
+  IL_005a:  br.s       IL_0078
+  IL_005c:  br.s       IL_0081
+  IL_005e:  br.s       IL_008a
+  IL_0060:  ldloc.1
+  IL_0061:  stloc.3
+  IL_0062:  br.s       IL_0064
+  IL_0064:  ldstr      ""Generic<long>.Color.""
+  IL_0069:  ldloc.3
+  IL_006a:  box        ""Generic<long>.Color""
+  IL_006f:  call       ""string string.Concat(object, object)""
+  IL_0074:  stloc.s    V_8
+  IL_0076:  br.s       IL_0093
+  IL_0078:  ldstr      ""Generic<object>.Color.Red""
+  IL_007d:  stloc.s    V_8
+  IL_007f:  br.s       IL_0093
+  IL_0081:  ldstr      ""Generic<dynamic>.Color.Blue""
+  IL_0086:  stloc.s    V_8
+  IL_0088:  br.s       IL_0093
+  IL_008a:  ldstr      ""None""
+  IL_008f:  stloc.s    V_8
+  IL_0091:  br.s       IL_0093
+  IL_0093:  ldloc.s    V_8
+  IL_0095:  ret
+}"
+            );
+        }
+
+        [Fact, WorkItem(19280, "https://github.com/dotnet/roslyn/issues/19280")]
+        public void ShareLikeKindedTemps_01()
+        {
+            var source = @"using System;
+
+public class Program
+{
+    public static void Main()
+    {
+    }
+    static bool b = false;
+    public static void M(object o)
+    {
+        switch (o)
+        {
+            case int i when b: break;
+            case var _ when b: break;
+            case int i when b: break;
+            case var _ when b: break;
+            case int i when b: break;
+            case var _ when b: break;
+            case int i when b: break;
+            case var _ when b: break;
+        }
+    }
+}";
+            var compVerifier = CompileAndVerify(source,
+                options: TestOptions.ReleaseDll.WithOutputKind(OutputKind.ConsoleApplication),
+                expectedOutput: "");
+            compVerifier.VerifyIL("Program.M",
+@"{
+  // Code size      203 (0xcb)
+  .maxstack  1
+  .locals init (object V_0,
+                int V_1,
+                int? V_2)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloc.0
+  IL_0003:  brfalse    IL_0094
+  IL_0008:  ldloc.0
+  IL_0009:  isinst     ""int?""
+  IL_000e:  unbox.any  ""int?""
+  IL_0013:  stloc.2
+  IL_0014:  ldloca.s   V_2
+  IL_0016:  call       ""int int?.GetValueOrDefault()""
+  IL_001b:  stloc.1
+  IL_001c:  ldloca.s   V_2
+  IL_001e:  call       ""bool int?.HasValue.get""
+  IL_0023:  brfalse.s  IL_0094
+  IL_0025:  br.s       IL_008d
+  IL_0027:  ldloc.0
+  IL_0028:  brfalse.s  IL_00a4
+  IL_002a:  ldloc.0
+  IL_002b:  isinst     ""int?""
+  IL_0030:  unbox.any  ""int?""
+  IL_0035:  stloc.2
+  IL_0036:  ldloca.s   V_2
+  IL_0038:  call       ""int int?.GetValueOrDefault()""
+  IL_003d:  stloc.1
+  IL_003e:  ldloca.s   V_2
+  IL_0040:  call       ""bool int?.HasValue.get""
+  IL_0045:  brfalse.s  IL_00a4
+  IL_0047:  br.s       IL_009d
+  IL_0049:  ldloc.0
+  IL_004a:  brfalse.s  IL_00b4
+  IL_004c:  ldloc.0
+  IL_004d:  isinst     ""int?""
+  IL_0052:  unbox.any  ""int?""
+  IL_0057:  stloc.2
+  IL_0058:  ldloca.s   V_2
+  IL_005a:  call       ""int int?.GetValueOrDefault()""
+  IL_005f:  stloc.1
+  IL_0060:  ldloca.s   V_2
+  IL_0062:  call       ""bool int?.HasValue.get""
+  IL_0067:  brfalse.s  IL_00b4
+  IL_0069:  br.s       IL_00ad
+  IL_006b:  ldloc.0
+  IL_006c:  brfalse.s  IL_00c4
+  IL_006e:  ldloc.0
+  IL_006f:  isinst     ""int?""
+  IL_0074:  unbox.any  ""int?""
+  IL_0079:  stloc.2
+  IL_007a:  ldloca.s   V_2
+  IL_007c:  call       ""int int?.GetValueOrDefault()""
+  IL_0081:  stloc.1
+  IL_0082:  ldloca.s   V_2
+  IL_0084:  call       ""bool int?.HasValue.get""
+  IL_0089:  brfalse.s  IL_00c4
+  IL_008b:  br.s       IL_00bd
+  IL_008d:  ldsfld     ""bool Program.b""
+  IL_0092:  brtrue.s   IL_00ca
+  IL_0094:  ldsfld     ""bool Program.b""
+  IL_0099:  brtrue.s   IL_00ca
+  IL_009b:  br.s       IL_0027
+  IL_009d:  ldsfld     ""bool Program.b""
+  IL_00a2:  brtrue.s   IL_00ca
+  IL_00a4:  ldsfld     ""bool Program.b""
+  IL_00a9:  brtrue.s   IL_00ca
+  IL_00ab:  br.s       IL_0049
+  IL_00ad:  ldsfld     ""bool Program.b""
+  IL_00b2:  brtrue.s   IL_00ca
+  IL_00b4:  ldsfld     ""bool Program.b""
+  IL_00b9:  brtrue.s   IL_00ca
+  IL_00bb:  br.s       IL_006b
+  IL_00bd:  ldsfld     ""bool Program.b""
+  IL_00c2:  brtrue.s   IL_00ca
+  IL_00c4:  ldsfld     ""bool Program.b""
+  IL_00c9:  pop
+  IL_00ca:  ret
+}"
+            );
+            compVerifier = CompileAndVerify(source,
+                options: TestOptions.DebugDll.WithOutputKind(OutputKind.ConsoleApplication),
+                expectedOutput: "");
+            compVerifier.VerifyIL("Program.M",
+@"{
+  // Code size      276 (0x114)
+  .maxstack  1
+  .locals init (object V_0,
+                int V_1,
+                int V_2, //i
+                int V_3, //i
+                int V_4, //i
+                int V_5, //i
+                object V_6,
+                int? V_7)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.s    V_6
+  IL_0004:  ldloc.s    V_6
+  IL_0006:  stloc.0
+  IL_0007:  ldloc.0
+  IL_0008:  brtrue.s   IL_000c
+  IL_000a:  br.s       IL_002c
+  IL_000c:  ldloc.0
+  IL_000d:  isinst     ""int?""
+  IL_0012:  unbox.any  ""int?""
+  IL_0017:  stloc.s    V_7
+  IL_0019:  ldloca.s   V_7
+  IL_001b:  call       ""int int?.GetValueOrDefault()""
+  IL_0020:  stloc.1
+  IL_0021:  ldloca.s   V_7
+  IL_0023:  call       ""bool int?.HasValue.get""
+  IL_0028:  brfalse.s  IL_002c
+  IL_002a:  br.s       IL_00a8
+  IL_002c:  br         IL_00b8
+  IL_0031:  ldloc.0
+  IL_0032:  brtrue.s   IL_0036
+  IL_0034:  br.s       IL_0056
+  IL_0036:  ldloc.0
+  IL_0037:  isinst     ""int?""
+  IL_003c:  unbox.any  ""int?""
+  IL_0041:  stloc.s    V_7
   IL_0043:  ldloca.s   V_7
-  IL_0045:  call       ""bool Generic<object>.Color?.HasValue.get""
-  IL_004a:  brfalse.s  IL_0060
-  IL_004c:  ldloc.2
-  IL_004d:  stloc.s    V_8
-  IL_004f:  ldloc.s    V_8
-  IL_0051:  brfalse.s  IL_005c
-  IL_0053:  br.s       IL_0055
-  IL_0055:  ldloc.s    V_8
-  IL_0057:  ldc.i4.1
-  IL_0058:  beq.s      IL_005e
-  IL_005a:  br.s       IL_0060
-  IL_005c:  br.s       IL_007c
-  IL_005e:  br.s       IL_0085
-  IL_0060:  br.s       IL_008e
-  IL_0062:  ldloc.1
-  IL_0063:  stloc.s    V_4
-  IL_0065:  br.s       IL_0067
-  IL_0067:  ldstr      ""Generic<long>.Color.""
-  IL_006c:  ldloc.s    V_4
-  IL_006e:  box        ""Generic<long>.Color""
-  IL_0073:  call       ""string string.Concat(object, object)""
-  IL_0078:  stloc.s    V_9
-  IL_007a:  br.s       IL_0097
-  IL_007c:  ldstr      ""Generic<object>.Color.Red""
-  IL_0081:  stloc.s    V_9
-  IL_0083:  br.s       IL_0097
-  IL_0085:  ldstr      ""Generic<dynamic>.Color.Blue""
-  IL_008a:  stloc.s    V_9
-  IL_008c:  br.s       IL_0097
-  IL_008e:  ldstr      ""None""
-  IL_0093:  stloc.s    V_9
-  IL_0095:  br.s       IL_0097
-  IL_0097:  ldloc.s    V_9
-  IL_0099:  ret
+  IL_0045:  call       ""int int?.GetValueOrDefault()""
+  IL_004a:  stloc.1
+  IL_004b:  ldloca.s   V_7
+  IL_004d:  call       ""bool int?.HasValue.get""
+  IL_0052:  brfalse.s  IL_0056
+  IL_0054:  br.s       IL_00c6
+  IL_0056:  br.s       IL_00d3
+  IL_0058:  ldloc.0
+  IL_0059:  brtrue.s   IL_005d
+  IL_005b:  br.s       IL_007d
+  IL_005d:  ldloc.0
+  IL_005e:  isinst     ""int?""
+  IL_0063:  unbox.any  ""int?""
+  IL_0068:  stloc.s    V_7
+  IL_006a:  ldloca.s   V_7
+  IL_006c:  call       ""int int?.GetValueOrDefault()""
+  IL_0071:  stloc.1
+  IL_0072:  ldloca.s   V_7
+  IL_0074:  call       ""bool int?.HasValue.get""
+  IL_0079:  brfalse.s  IL_007d
+  IL_007b:  br.s       IL_00e1
+  IL_007d:  br.s       IL_00ef
+  IL_007f:  ldloc.0
+  IL_0080:  brtrue.s   IL_0084
+  IL_0082:  br.s       IL_00a4
+  IL_0084:  ldloc.0
+  IL_0085:  isinst     ""int?""
+  IL_008a:  unbox.any  ""int?""
+  IL_008f:  stloc.s    V_7
+  IL_0091:  ldloca.s   V_7
+  IL_0093:  call       ""int int?.GetValueOrDefault()""
+  IL_0098:  stloc.1
+  IL_0099:  ldloca.s   V_7
+  IL_009b:  call       ""bool int?.HasValue.get""
+  IL_00a0:  brfalse.s  IL_00a4
+  IL_00a2:  br.s       IL_00fa
+  IL_00a4:  br.s       IL_0108
+  IL_00a6:  br.s       IL_0113
+  IL_00a8:  ldloc.1
+  IL_00a9:  stloc.2
+  IL_00aa:  ldsfld     ""bool Program.b""
+  IL_00af:  brtrue.s   IL_00b6
+  IL_00b1:  br         IL_002c
+  IL_00b6:  br.s       IL_0113
+  IL_00b8:  ldsfld     ""bool Program.b""
+  IL_00bd:  brtrue.s   IL_00c4
+  IL_00bf:  br         IL_0031
+  IL_00c4:  br.s       IL_0113
+  IL_00c6:  ldloc.1
+  IL_00c7:  stloc.3
+  IL_00c8:  ldsfld     ""bool Program.b""
+  IL_00cd:  brtrue.s   IL_00d1
+  IL_00cf:  br.s       IL_0056
+  IL_00d1:  br.s       IL_0113
+  IL_00d3:  ldsfld     ""bool Program.b""
+  IL_00d8:  brtrue.s   IL_00df
+  IL_00da:  br         IL_0058
+  IL_00df:  br.s       IL_0113
+  IL_00e1:  ldloc.1
+  IL_00e2:  stloc.s    V_4
+  IL_00e4:  ldsfld     ""bool Program.b""
+  IL_00e9:  brtrue.s   IL_00ed
+  IL_00eb:  br.s       IL_007d
+  IL_00ed:  br.s       IL_0113
+  IL_00ef:  ldsfld     ""bool Program.b""
+  IL_00f4:  brtrue.s   IL_00f8
+  IL_00f6:  br.s       IL_007f
+  IL_00f8:  br.s       IL_0113
+  IL_00fa:  ldloc.1
+  IL_00fb:  stloc.s    V_5
+  IL_00fd:  ldsfld     ""bool Program.b""
+  IL_0102:  brtrue.s   IL_0106
+  IL_0104:  br.s       IL_00a4
+  IL_0106:  br.s       IL_0113
+  IL_0108:  ldsfld     ""bool Program.b""
+  IL_010d:  brtrue.s   IL_0111
+  IL_010f:  br.s       IL_00a6
+  IL_0111:  br.s       IL_0113
+  IL_0113:  ret
+}"
+            );
+            compVerifier.VerifyPdb(
+@"<symbols>
+  <entryPoint declaringType=""Program"" methodName=""Main"" />
+  <methods>
+    <method containingType=""Program"" name=""Main"">
+      <customDebugInfo>
+        <using>
+          <namespace usingCount=""1"" />
+        </using>
+      </customDebugInfo>
+      <sequencePoints>
+        <entry offset=""0x0"" startLine=""6"" startColumn=""5"" endLine=""6"" endColumn=""6"" />
+        <entry offset=""0x1"" startLine=""7"" startColumn=""5"" endLine=""7"" endColumn=""6"" />
+      </sequencePoints>
+      <scope startOffset=""0x0"" endOffset=""0x2"">
+        <namespace name=""System"" />
+      </scope>
+    </method>
+    <method containingType=""Program"" name=""M"" parameterNames=""o"">
+      <customDebugInfo>
+        <forward declaringType=""Program"" methodName=""Main"" />
+        <encLocalSlotMap>
+          <slot kind=""35"" offset=""11"" />
+          <slot kind=""35"" offset=""46"" />
+          <slot kind=""0"" offset=""55"" />
+          <slot kind=""0"" offset=""133"" />
+          <slot kind=""0"" offset=""211"" />
+          <slot kind=""0"" offset=""289"" />
+          <slot kind=""1"" offset=""11"" />
+          <slot kind=""temp"" />
+        </encLocalSlotMap>
+      </customDebugInfo>
+      <sequencePoints>
+        <entry offset=""0x0"" startLine=""10"" startColumn=""5"" endLine=""10"" endColumn=""6"" />
+        <entry offset=""0x1"" startLine=""11"" startColumn=""9"" endLine=""11"" endColumn=""19"" />
+        <entry offset=""0x4"" hidden=""true"" />
+        <entry offset=""0xa8"" hidden=""true"" />
+        <entry offset=""0xaa"" startLine=""13"" startColumn=""24"" endLine=""13"" endColumn=""30"" />
+        <entry offset=""0xb6"" startLine=""13"" startColumn=""32"" endLine=""13"" endColumn=""38"" />
+        <entry offset=""0xb8"" startLine=""14"" startColumn=""24"" endLine=""14"" endColumn=""30"" />
+        <entry offset=""0xc4"" startLine=""14"" startColumn=""32"" endLine=""14"" endColumn=""38"" />
+        <entry offset=""0xc6"" hidden=""true"" />
+        <entry offset=""0xc8"" startLine=""15"" startColumn=""24"" endLine=""15"" endColumn=""30"" />
+        <entry offset=""0xd1"" startLine=""15"" startColumn=""32"" endLine=""15"" endColumn=""38"" />
+        <entry offset=""0xd3"" startLine=""16"" startColumn=""24"" endLine=""16"" endColumn=""30"" />
+        <entry offset=""0xdf"" startLine=""16"" startColumn=""32"" endLine=""16"" endColumn=""38"" />
+        <entry offset=""0xe1"" hidden=""true"" />
+        <entry offset=""0xe4"" startLine=""17"" startColumn=""24"" endLine=""17"" endColumn=""30"" />
+        <entry offset=""0xed"" startLine=""17"" startColumn=""32"" endLine=""17"" endColumn=""38"" />
+        <entry offset=""0xef"" startLine=""18"" startColumn=""24"" endLine=""18"" endColumn=""30"" />
+        <entry offset=""0xf8"" startLine=""18"" startColumn=""32"" endLine=""18"" endColumn=""38"" />
+        <entry offset=""0xfa"" hidden=""true"" />
+        <entry offset=""0xfd"" startLine=""19"" startColumn=""24"" endLine=""19"" endColumn=""30"" />
+        <entry offset=""0x106"" startLine=""19"" startColumn=""32"" endLine=""19"" endColumn=""38"" />
+        <entry offset=""0x108"" startLine=""20"" startColumn=""24"" endLine=""20"" endColumn=""30"" />
+        <entry offset=""0x111"" startLine=""20"" startColumn=""32"" endLine=""20"" endColumn=""38"" />
+        <entry offset=""0x113"" startLine=""22"" startColumn=""5"" endLine=""22"" endColumn=""6"" />
+      </sequencePoints>
+      <scope startOffset=""0x0"" endOffset=""0x114"">
+        <scope startOffset=""0xa8"" endOffset=""0xb8"">
+          <local name=""i"" il_index=""2"" il_start=""0xa8"" il_end=""0xb8"" attributes=""0"" />
+        </scope>
+        <scope startOffset=""0xc6"" endOffset=""0xd3"">
+          <local name=""i"" il_index=""3"" il_start=""0xc6"" il_end=""0xd3"" attributes=""0"" />
+        </scope>
+        <scope startOffset=""0xe1"" endOffset=""0xef"">
+          <local name=""i"" il_index=""4"" il_start=""0xe1"" il_end=""0xef"" attributes=""0"" />
+        </scope>
+        <scope startOffset=""0xfa"" endOffset=""0x108"">
+          <local name=""i"" il_index=""5"" il_start=""0xfa"" il_end=""0x108"" attributes=""0"" />
+        </scope>
+      </scope>
+    </method>
+    <method containingType=""Program"" name="".cctor"">
+      <customDebugInfo>
+        <forward declaringType=""Program"" methodName=""Main"" />
+      </customDebugInfo>
+      <sequencePoints>
+        <entry offset=""0x0"" startLine=""8"" startColumn=""5"" endLine=""8"" endColumn=""27"" />
+      </sequencePoints>
+    </method>
+  </methods>
+</symbols>");
+        }
+
+        [Fact, WorkItem(19280, "https://github.com/dotnet/roslyn/issues/19280")]
+        public void TestSignificanceOfDynamicVersusObjectAndTupleNamesInUniquenessOfPatternMatchingTemps()
+        {
+            var source =
+@"using System;
+public class Generic<T,U>
+{
+}
+class Program
+{
+    public static void Main(string[] args)
+    {
+        var g = new Generic<object, (int, int)>();
+        M2(g, true, false, false);
+        M2(g, false, true, false);
+        M2(g, false, false, true);
+    }
+    public static void M2(object o, bool b1, bool b2, bool b3)
+    {
+        switch (o)
+        {
+            case Generic<object, (int a, int b)> g when b1: Console.Write(""a""); break;
+            case var _ when b2: Console.Write(""b""); break;
+            case Generic<dynamic, (int x, int y)> g when b3: Console.Write(""c""); break;
+        }
+    }
+}
+";
+            var compilation = CreateStandardCompilation(source,
+                    options: TestOptions.DebugDll.WithOutputKind(OutputKind.ConsoleApplication),
+                    references: new[] { ValueTupleRef, SystemRuntimeFacadeRef })
+                .VerifyDiagnostics();
+            var compVerifier = CompileAndVerify(compilation, expectedOutput: "abc");
+            compVerifier.VerifyIL("Program.M2",
+@"{
+  // Code size      105 (0x69)
+  .maxstack  2
+  .locals init (object V_0,
+                Generic<object, (int a, int b)> V_1,
+                Generic<dynamic, (int x, int y)> V_2,
+                Generic<object, (int a, int b)> V_3, //g
+                Generic<dynamic, (int x, int y)> V_4, //g
+                object V_5)
+  IL_0000:  nop
+  IL_0001:  ldarg.0
+  IL_0002:  stloc.s    V_5
+  IL_0004:  ldloc.s    V_5
+  IL_0006:  stloc.0
+  IL_0007:  ldloc.0
+  IL_0008:  brtrue.s   IL_000c
+  IL_000a:  br.s       IL_0018
+  IL_000c:  ldloc.0
+  IL_000d:  isinst     ""Generic<object, (int a, int b)>""
+  IL_0012:  dup
+  IL_0013:  stloc.1
+  IL_0014:  brfalse.s  IL_0018
+  IL_0016:  br.s       IL_002d
+  IL_0018:  br.s       IL_0041
+  IL_001a:  ldloc.0
+  IL_001b:  brtrue.s   IL_001f
+  IL_001d:  br.s       IL_002b
+  IL_001f:  ldloc.0
+  IL_0020:  isinst     ""Generic<dynamic, (int x, int y)>""
+  IL_0025:  dup
+  IL_0026:  stloc.2
+  IL_0027:  brfalse.s  IL_002b
+  IL_0029:  br.s       IL_0053
+  IL_002b:  br.s       IL_0068
+  IL_002d:  ldloc.1
+  IL_002e:  stloc.3
+  IL_002f:  ldarg.1
+  IL_0030:  brtrue.s   IL_0034
+  IL_0032:  br.s       IL_0018
+  IL_0034:  ldstr      ""a""
+  IL_0039:  call       ""void System.Console.Write(string)""
+  IL_003e:  nop
+  IL_003f:  br.s       IL_0068
+  IL_0041:  ldarg.2
+  IL_0042:  brtrue.s   IL_0046
+  IL_0044:  br.s       IL_001a
+  IL_0046:  ldstr      ""b""
+  IL_004b:  call       ""void System.Console.Write(string)""
+  IL_0050:  nop
+  IL_0051:  br.s       IL_0068
+  IL_0053:  ldloc.2
+  IL_0054:  stloc.s    V_4
+  IL_0056:  ldarg.3
+  IL_0057:  brtrue.s   IL_005b
+  IL_0059:  br.s       IL_002b
+  IL_005b:  ldstr      ""c""
+  IL_0060:  call       ""void System.Console.Write(string)""
+  IL_0065:  nop
+  IL_0066:  br.s       IL_0068
+  IL_0068:  ret
 }"
             );
         }
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
index fd713ce68d083..2d38589676392 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
@@ -2850,7 +2850,6 @@ class Student : Person { public double GPA; }
           <slot kind=""35"" offset=""11"" />
           <slot kind=""35"" offset=""46"" />
           <slot kind=""35"" offset=""237"" />
-          <slot kind=""temp"" />
           <slot kind=""0"" offset=""59"" />
           <slot kind=""0"" offset=""163"" />
           <slot kind=""0"" offset=""250"" />
@@ -2861,32 +2860,31 @@ class Student : Person { public double GPA; }
       <sequencePoints>
         <entry offset=""0x0"" startLine=""19"" startColumn=""5"" endLine=""19"" endColumn=""6"" />
         <entry offset=""0x1"" startLine=""20"" startColumn=""9"" endLine=""20"" endColumn=""19"" />
-        <entry offset=""0x6"" hidden=""true"" />
-        <entry offset=""0x2a"" hidden=""true"" />
-        <entry offset=""0x2d"" startLine=""22"" startColumn=""28"" endLine=""22"" endColumn=""44"" />
-        <entry offset=""0x41"" startLine=""23"" startColumn=""17"" endLine=""23"" endColumn=""57"" />
-        <entry offset=""0x62"" hidden=""true"" />
-        <entry offset=""0x67"" startLine=""25"" startColumn=""17"" endLine=""25"" endColumn=""57"" />
-        <entry offset=""0x88"" hidden=""true"" />
-        <entry offset=""0x8d"" startLine=""27"" startColumn=""17"" endLine=""27"" endColumn=""59"" />
-        <entry offset=""0xa9"" startLine=""29"" startColumn=""17"" endLine=""29"" endColumn=""43"" />
-        <entry offset=""0xbd"" startLine=""31"" startColumn=""5"" endLine=""31"" endColumn=""6"" />
+        <entry offset=""0x4"" hidden=""true"" />
+        <entry offset=""0x28"" hidden=""true"" />
+        <entry offset=""0x2a"" startLine=""22"" startColumn=""28"" endLine=""22"" endColumn=""44"" />
+        <entry offset=""0x3d"" startLine=""23"" startColumn=""17"" endLine=""23"" endColumn=""57"" />
+        <entry offset=""0x5c"" hidden=""true"" />
+        <entry offset=""0x61"" startLine=""25"" startColumn=""17"" endLine=""25"" endColumn=""57"" />
+        <entry offset=""0x82"" hidden=""true"" />
+        <entry offset=""0x87"" startLine=""27"" startColumn=""17"" endLine=""27"" endColumn=""59"" />
+        <entry offset=""0xa3"" startLine=""29"" startColumn=""17"" endLine=""29"" endColumn=""43"" />
+        <entry offset=""0xb7"" startLine=""31"" startColumn=""5"" endLine=""31"" endColumn=""6"" />
       </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0xc0"">
-        <scope startOffset=""0x2a"" endOffset=""0x62"">
-          <local name=""s"" il_index=""4"" il_start=""0x2a"" il_end=""0x62"" attributes=""0"" />
+      <scope startOffset=""0x0"" endOffset=""0xba"">
+        <scope startOffset=""0x28"" endOffset=""0x5c"">
+          <local name=""s"" il_index=""3"" il_start=""0x28"" il_end=""0x5c"" attributes=""0"" />
         </scope>
-        <scope startOffset=""0x62"" endOffset=""0x88"">
-          <local name=""s"" il_index=""5"" il_start=""0x62"" il_end=""0x88"" attributes=""0"" />
+        <scope startOffset=""0x5c"" endOffset=""0x82"">
+          <local name=""s"" il_index=""4"" il_start=""0x5c"" il_end=""0x82"" attributes=""0"" />
         </scope>
-        <scope startOffset=""0x88"" endOffset=""0xa9"">
-          <local name=""t"" il_index=""6"" il_start=""0x88"" il_end=""0xa9"" attributes=""0"" />
+        <scope startOffset=""0x82"" endOffset=""0xa3"">
+          <local name=""t"" il_index=""5"" il_start=""0x82"" il_end=""0xa3"" attributes=""0"" />
         </scope>
       </scope>
     </method>
   </methods>
-</symbols>"
-);
+</symbols>");
         }
 
         [Fact]
@@ -2943,7 +2941,6 @@ class Student : Person { public double GPA; }
           <slot kind=""35"" offset=""11"" />
           <slot kind=""35"" offset=""46"" />
           <slot kind=""35"" offset=""249"" />
-          <slot kind=""temp"" />
           <slot kind=""1"" offset=""11"" />
           <slot kind=""21"" offset=""0"" />
         </encLocalSlotMap>
@@ -2961,27 +2958,26 @@ class Student : Person { public double GPA; }
         <entry offset=""0x0"" hidden=""true"" />
         <entry offset=""0xd"" startLine=""19"" startColumn=""5"" endLine=""19"" endColumn=""6"" />
         <entry offset=""0xe"" hidden=""true"" />
-        <entry offset=""0x20"" hidden=""true"" />
-        <entry offset=""0x45"" hidden=""true"" />
-        <entry offset=""0x4c"" startLine=""22"" startColumn=""28"" endLine=""22"" endColumn=""44"" />
-        <entry offset=""0x64"" startLine=""23"" startColumn=""17"" endLine=""23"" endColumn=""63"" />
-        <entry offset=""0x74"" hidden=""true"" />
-        <entry offset=""0x7d"" startLine=""25"" startColumn=""17"" endLine=""25"" endColumn=""63"" />
-        <entry offset=""0x8d"" hidden=""true"" />
-        <entry offset=""0x97"" startLine=""27"" startColumn=""17"" endLine=""27"" endColumn=""65"" />
-        <entry offset=""0xa7"" startLine=""29"" startColumn=""17"" endLine=""29"" endColumn=""49"" />
-        <entry offset=""0xb7"" startLine=""31"" startColumn=""5"" endLine=""31"" endColumn=""6"" />
+        <entry offset=""0x1c"" hidden=""true"" />
+        <entry offset=""0x41"" hidden=""true"" />
+        <entry offset=""0x48"" startLine=""22"" startColumn=""28"" endLine=""22"" endColumn=""44"" />
+        <entry offset=""0x60"" startLine=""23"" startColumn=""17"" endLine=""23"" endColumn=""63"" />
+        <entry offset=""0x70"" hidden=""true"" />
+        <entry offset=""0x79"" startLine=""25"" startColumn=""17"" endLine=""25"" endColumn=""63"" />
+        <entry offset=""0x89"" hidden=""true"" />
+        <entry offset=""0x93"" startLine=""27"" startColumn=""17"" endLine=""27"" endColumn=""65"" />
+        <entry offset=""0xa3"" startLine=""29"" startColumn=""17"" endLine=""29"" endColumn=""49"" />
+        <entry offset=""0xb3"" startLine=""31"" startColumn=""5"" endLine=""31"" endColumn=""6"" />
       </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0xba"">
-        <local name=""CS$&lt;&gt;8__locals0"" il_index=""0"" il_start=""0x0"" il_end=""0xba"" attributes=""0"" />
-        <scope startOffset=""0xe"" endOffset=""0xb7"">
-          <local name=""CS$&lt;&gt;8__locals1"" il_index=""1"" il_start=""0xe"" il_end=""0xb7"" attributes=""0"" />
+      <scope startOffset=""0x0"" endOffset=""0xb6"">
+        <local name=""CS$&lt;&gt;8__locals0"" il_index=""0"" il_start=""0x0"" il_end=""0xb6"" attributes=""0"" />
+        <scope startOffset=""0xe"" endOffset=""0xb3"">
+          <local name=""CS$&lt;&gt;8__locals1"" il_index=""1"" il_start=""0xe"" il_end=""0xb3"" attributes=""0"" />
         </scope>
       </scope>
     </method>
   </methods>
-</symbols>"
-);
+</symbols>");
         }
 
         #endregion
@@ -6476,113 +6472,106 @@ static void M(object o)
             var c = CreateCompilationWithMscorlibAndSystemCore(source, options: TestOptions.DebugDll);
             CompileAndVerify(c).VerifyIL("Program.M",
 @"{
-  // Code size      202 (0xca)
+  // Code size      194 (0xc2)
   .maxstack  2
   .locals init (object V_0,
                 int V_1,
                 object V_2,
-                object V_3,
-                int? V_4,
-                object V_5,
-                int V_6,
+                int? V_3,
+                object V_4,
+                int V_5,
+                object V_6,
                 object V_7,
-                object V_8,
-                object V_9)
+                object V_8)
   IL_0000:  nop
   IL_0001:  ldarg.0
   IL_0002:  stloc.2
   IL_0003:  ldloc.2
-  IL_0004:  stloc.3
-  IL_0005:  ldloc.3
-  IL_0006:  stloc.0
-  IL_0007:  ldloc.0
-  IL_0008:  brtrue.s   IL_000c
-  IL_000a:  br.s       IL_005a
-  IL_000c:  ldloc.0
-  IL_000d:  isinst     ""int?""
-  IL_0012:  unbox.any  ""int?""
-  IL_0017:  stloc.s    V_4
-  IL_0019:  ldloca.s   V_4
-  IL_001b:  call       ""int int?.GetValueOrDefault()""
-  IL_0020:  stloc.1
-  IL_0021:  ldloca.s   V_4
-  IL_0023:  call       ""bool int?.HasValue.get""
-  IL_0028:  brfalse.s  IL_005a
-  IL_002a:  ldloc.1
-  IL_002b:  ldc.i4.1
-  IL_002c:  sub
-  IL_002d:  switch    (
-        IL_0048,
-        IL_0050,
-        IL_0056,
-        IL_004e,
-        IL_0054)
-  IL_0046:  br.s       IL_005a
-  IL_0048:  br.s       IL_005c
-  IL_004a:  br.s       IL_0068
-  IL_004c:  br.s       IL_0076
-  IL_004e:  br.s       IL_0066
-  IL_0050:  br.s       IL_0061
-  IL_0052:  br.s       IL_005a
-  IL_0054:  br.s       IL_0072
-  IL_0056:  br.s       IL_006d
-  IL_0058:  br.s       IL_005a
-  IL_005a:  br.s       IL_0074
-  IL_005c:  ldarg.0
-  IL_005d:  brfalse.s  IL_0066
-  IL_005f:  br.s       IL_004a
-  IL_0061:  ldarg.0
-  IL_0062:  brfalse.s  IL_0066
-  IL_0064:  br.s       IL_0052
-  IL_0066:  br.s       IL_0078
-  IL_0068:  ldarg.0
-  IL_0069:  brtrue.s   IL_0072
-  IL_006b:  br.s       IL_004c
-  IL_006d:  ldarg.0
-  IL_006e:  brtrue.s   IL_0072
-  IL_0070:  br.s       IL_0058
-  IL_0072:  br.s       IL_0078
-  IL_0074:  br.s       IL_0078
-  IL_0076:  br.s       IL_0078
-  IL_0078:  ldarg.0
-  IL_0079:  stloc.2
-  IL_007a:  ldloc.2
-  IL_007b:  stloc.s    V_7
-  IL_007d:  ldloc.s    V_7
-  IL_007f:  stloc.s    V_5
-  IL_0081:  ldloc.s    V_5
-  IL_0083:  brtrue.s   IL_0087
-  IL_0085:  br.s       IL_00b0
-  IL_0087:  ldloc.s    V_5
-  IL_0089:  isinst     ""int?""
-  IL_008e:  unbox.any  ""int?""
-  IL_0093:  stloc.s    V_4
-  IL_0095:  ldloca.s   V_4
-  IL_0097:  call       ""int int?.GetValueOrDefault()""
-  IL_009c:  stloc.s    V_6
-  IL_009e:  ldloca.s   V_4
-  IL_00a0:  call       ""bool int?.HasValue.get""
-  IL_00a5:  brfalse.s  IL_00b0
-  IL_00a7:  ldloc.s    V_6
-  IL_00a9:  ldc.i4.1
-  IL_00aa:  beq.s      IL_00ae
+  IL_0004:  stloc.0
+  IL_0005:  ldloc.0
+  IL_0006:  brtrue.s   IL_000a
+  IL_0008:  br.s       IL_0057
+  IL_000a:  ldloc.0
+  IL_000b:  isinst     ""int?""
+  IL_0010:  unbox.any  ""int?""
+  IL_0015:  stloc.3
+  IL_0016:  ldloca.s   V_3
+  IL_0018:  call       ""int int?.GetValueOrDefault()""
+  IL_001d:  stloc.1
+  IL_001e:  ldloca.s   V_3
+  IL_0020:  call       ""bool int?.HasValue.get""
+  IL_0025:  brfalse.s  IL_0057
+  IL_0027:  ldloc.1
+  IL_0028:  ldc.i4.1
+  IL_0029:  sub
+  IL_002a:  switch    (
+        IL_0045,
+        IL_004d,
+        IL_0053,
+        IL_004b,
+        IL_0051)
+  IL_0043:  br.s       IL_0057
+  IL_0045:  br.s       IL_0059
+  IL_0047:  br.s       IL_0065
+  IL_0049:  br.s       IL_0073
+  IL_004b:  br.s       IL_0063
+  IL_004d:  br.s       IL_005e
+  IL_004f:  br.s       IL_0057
+  IL_0051:  br.s       IL_006f
+  IL_0053:  br.s       IL_006a
+  IL_0055:  br.s       IL_0057
+  IL_0057:  br.s       IL_0071
+  IL_0059:  ldarg.0
+  IL_005a:  brfalse.s  IL_0063
+  IL_005c:  br.s       IL_0047
+  IL_005e:  ldarg.0
+  IL_005f:  brfalse.s  IL_0063
+  IL_0061:  br.s       IL_004f
+  IL_0063:  br.s       IL_0075
+  IL_0065:  ldarg.0
+  IL_0066:  brtrue.s   IL_006f
+  IL_0068:  br.s       IL_0049
+  IL_006a:  ldarg.0
+  IL_006b:  brtrue.s   IL_006f
+  IL_006d:  br.s       IL_0055
+  IL_006f:  br.s       IL_0075
+  IL_0071:  br.s       IL_0075
+  IL_0073:  br.s       IL_0075
+  IL_0075:  ldarg.0
+  IL_0076:  stloc.s    V_6
+  IL_0078:  ldloc.s    V_6
+  IL_007a:  stloc.s    V_4
+  IL_007c:  ldloc.s    V_4
+  IL_007e:  brtrue.s   IL_0082
+  IL_0080:  br.s       IL_00aa
+  IL_0082:  ldloc.s    V_4
+  IL_0084:  isinst     ""int?""
+  IL_0089:  unbox.any  ""int?""
+  IL_008e:  stloc.3
+  IL_008f:  ldloca.s   V_3
+  IL_0091:  call       ""int int?.GetValueOrDefault()""
+  IL_0096:  stloc.s    V_5
+  IL_0098:  ldloca.s   V_3
+  IL_009a:  call       ""bool int?.HasValue.get""
+  IL_009f:  brfalse.s  IL_00aa
+  IL_00a1:  ldloc.s    V_5
+  IL_00a3:  ldc.i4.1
+  IL_00a4:  beq.s      IL_00a8
+  IL_00a6:  br.s       IL_00aa
+  IL_00a8:  br.s       IL_00ac
+  IL_00aa:  br.s       IL_00ae
   IL_00ac:  br.s       IL_00b0
-  IL_00ae:  br.s       IL_00b2
-  IL_00b0:  br.s       IL_00b4
-  IL_00b2:  br.s       IL_00b6
-  IL_00b4:  br.s       IL_00b6
-  IL_00b6:  ldarg.0
-  IL_00b7:  stloc.2
-  IL_00b8:  ldloc.2
-  IL_00b9:  stloc.s    V_9
-  IL_00bb:  ldloc.s    V_9
-  IL_00bd:  stloc.s    V_8
-  IL_00bf:  ldloc.s    V_8
-  IL_00c1:  brtrue.s   IL_00c5
-  IL_00c3:  br.s       IL_00c5
-  IL_00c5:  br.s       IL_00c7
-  IL_00c7:  br.s       IL_00c9
-  IL_00c9:  ret
+  IL_00ae:  br.s       IL_00b0
+  IL_00b0:  ldarg.0
+  IL_00b1:  stloc.s    V_8
+  IL_00b3:  ldloc.s    V_8
+  IL_00b5:  stloc.s    V_7
+  IL_00b7:  ldloc.s    V_7
+  IL_00b9:  brtrue.s   IL_00bd
+  IL_00bb:  br.s       IL_00bd
+  IL_00bd:  br.s       IL_00bf
+  IL_00bf:  br.s       IL_00c1
+  IL_00c1:  ret
 }");
             c.VerifyPdb(
 @"<symbols>
@@ -6595,7 +6584,6 @@ .locals init (object V_0,
         <encLocalSlotMap>
           <slot kind=""35"" offset=""11"" />
           <slot kind=""35"" offset=""46"" />
-          <slot kind=""temp"" />
           <slot kind=""1"" offset=""11"" />
           <slot kind=""temp"" />
           <slot kind=""35"" offset=""378"" />
@@ -6608,23 +6596,23 @@ .locals init (object V_0,
       <sequencePoints>
         <entry offset=""0x0"" startLine=""4"" startColumn=""5"" endLine=""4"" endColumn=""6"" />
         <entry offset=""0x1"" startLine=""5"" startColumn=""9"" endLine=""5"" endColumn=""19"" />
-        <entry offset=""0x5"" hidden=""true"" />
-        <entry offset=""0x5c"" startLine=""7"" startColumn=""20"" endLine=""7"" endColumn=""34"" />
-        <entry offset=""0x61"" startLine=""9"" startColumn=""20"" endLine=""9"" endColumn=""34"" />
-        <entry offset=""0x66"" startLine=""10"" startColumn=""17"" endLine=""10"" endColumn=""23"" />
-        <entry offset=""0x68"" startLine=""11"" startColumn=""20"" endLine=""11"" endColumn=""34"" />
-        <entry offset=""0x6d"" startLine=""13"" startColumn=""20"" endLine=""13"" endColumn=""34"" />
-        <entry offset=""0x72"" startLine=""14"" startColumn=""17"" endLine=""14"" endColumn=""23"" />
-        <entry offset=""0x74"" startLine=""16"" startColumn=""17"" endLine=""16"" endColumn=""23"" />
-        <entry offset=""0x76"" startLine=""18"" startColumn=""17"" endLine=""18"" endColumn=""23"" />
-        <entry offset=""0x78"" startLine=""20"" startColumn=""9"" endLine=""20"" endColumn=""19"" />
-        <entry offset=""0x7d"" hidden=""true"" />
-        <entry offset=""0xb2"" startLine=""23"" startColumn=""17"" endLine=""23"" endColumn=""23"" />
-        <entry offset=""0xb4"" startLine=""25"" startColumn=""17"" endLine=""25"" endColumn=""23"" />
-        <entry offset=""0xb6"" startLine=""27"" startColumn=""9"" endLine=""27"" endColumn=""19"" />
-        <entry offset=""0xbb"" hidden=""true"" />
-        <entry offset=""0xc7"" startLine=""30"" startColumn=""17"" endLine=""30"" endColumn=""23"" />
-        <entry offset=""0xc9"" startLine=""32"" startColumn=""5"" endLine=""32"" endColumn=""6"" />
+        <entry offset=""0x3"" hidden=""true"" />
+        <entry offset=""0x59"" startLine=""7"" startColumn=""20"" endLine=""7"" endColumn=""34"" />
+        <entry offset=""0x5e"" startLine=""9"" startColumn=""20"" endLine=""9"" endColumn=""34"" />
+        <entry offset=""0x63"" startLine=""10"" startColumn=""17"" endLine=""10"" endColumn=""23"" />
+        <entry offset=""0x65"" startLine=""11"" startColumn=""20"" endLine=""11"" endColumn=""34"" />
+        <entry offset=""0x6a"" startLine=""13"" startColumn=""20"" endLine=""13"" endColumn=""34"" />
+        <entry offset=""0x6f"" startLine=""14"" startColumn=""17"" endLine=""14"" endColumn=""23"" />
+        <entry offset=""0x71"" startLine=""16"" startColumn=""17"" endLine=""16"" endColumn=""23"" />
+        <entry offset=""0x73"" startLine=""18"" startColumn=""17"" endLine=""18"" endColumn=""23"" />
+        <entry offset=""0x75"" startLine=""20"" startColumn=""9"" endLine=""20"" endColumn=""19"" />
+        <entry offset=""0x78"" hidden=""true"" />
+        <entry offset=""0xac"" startLine=""23"" startColumn=""17"" endLine=""23"" endColumn=""23"" />
+        <entry offset=""0xae"" startLine=""25"" startColumn=""17"" endLine=""25"" endColumn=""23"" />
+        <entry offset=""0xb0"" startLine=""27"" startColumn=""9"" endLine=""27"" endColumn=""19"" />
+        <entry offset=""0xb3"" hidden=""true"" />
+        <entry offset=""0xbf"" startLine=""30"" startColumn=""17"" endLine=""30"" endColumn=""23"" />
+        <entry offset=""0xc1"" startLine=""32"" startColumn=""5"" endLine=""32"" endColumn=""6"" />
       </sequencePoints>
     </method>
   </methods>
diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs
index dd41414e39b75..eeb555bc02e1f 100644
--- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs
+++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs
@@ -167,12 +167,11 @@ .maxstack  1
   .locals init (object V_0,
                 string V_1,
                 int V_2,
-                object V_3,
-                string V_4, //a
-                string V_5, //s
-                int V_6,
-                object V_7,
-                int? V_8)
+                string V_3, //a
+                string V_4, //s
+                int V_5,
+                object V_6,
+                int? V_7)
   IL_0000:  ldarg.0
   IL_0001:  ret
 }");
@@ -183,32 +182,29 @@ .maxstack  1
   .locals init (object V_0,
                 string V_1,
                 int V_2,
-                object V_3,
-                string V_4, //a
-                string V_5, //s
-                int V_6,
-                object V_7,
-                int? V_8)
+                string V_3, //a
+                string V_4, //s
+                int V_5,
+                object V_6,
+                int? V_7)
   IL_0000:  ldarg.1
   IL_0001:  ret
 }");
                 VerifyLocal(testData, typeName, locals[2], "<>m2", "a", expectedILOpt:
 @"{
-  // Code size        3 (0x3)
+  // Code size        2 (0x2)
   .maxstack  1
   .locals init (object V_0,
                 string V_1,
                 int V_2,
-                object V_3,
-                string V_4, //a
-                string V_5, //s
-                int V_6,
-                object V_7,
-                int? V_8)
-  IL_0000:  ldloc.s    V_4
-  IL_0002:  ret
-}
-");
+                string V_3, //a
+                string V_4, //s
+                int V_5,
+                object V_6,
+                int? V_7)
+  IL_0000:  ldloc.3
+  IL_0001:  ret
+}");
                 VerifyLocal(testData, typeName, locals[3], "<>m3", "s", expectedILOpt:
 @"{
   // Code size        3 (0x3)
@@ -216,13 +212,12 @@ .maxstack  1
   .locals init (object V_0,
                 string V_1,
                 int V_2,
-                object V_3,
-                string V_4, //a
-                string V_5, //s
-                int V_6,
-                object V_7,
-                int? V_8)
-  IL_0000:  ldloc.s    V_5
+                string V_3, //a
+                string V_4, //s
+                int V_5,
+                object V_6,
+                int? V_7)
+  IL_0000:  ldloc.s    V_4
   IL_0002:  ret
 }");
                 locals.Free();
@@ -243,12 +238,11 @@ .maxstack  1
   .locals init (object V_0,
                 string V_1,
                 int V_2,
-                object V_3,
-                string V_4, //a
-                string V_5,
-                int V_6, //s
-                object V_7,
-                int? V_8)
+                string V_3, //a
+                string V_4,
+                int V_5, //s
+                object V_6,
+                int? V_7)
   IL_0000:  ldarg.0
   IL_0001:  ret
 }");
@@ -259,32 +253,29 @@ .maxstack  1
   .locals init (object V_0,
                 string V_1,
                 int V_2,
-                object V_3,
-                string V_4, //a
-                string V_5,
-                int V_6, //s
-                object V_7,
-                int? V_8)
+                string V_3, //a
+                string V_4,
+                int V_5, //s
+                object V_6,
+                int? V_7)
   IL_0000:  ldarg.1
   IL_0001:  ret
 }");
                 VerifyLocal(testData, typeName, locals[2], "<>m2", "a", expectedILOpt:
 @"{
-  // Code size        3 (0x3)
+  // Code size        2 (0x2)
   .maxstack  1
   .locals init (object V_0,
                 string V_1,
                 int V_2,
-                object V_3,
-                string V_4, //a
-                string V_5,
-                int V_6, //s
-                object V_7,
-                int? V_8)
-  IL_0000:  ldloc.s    V_4
-  IL_0002:  ret
-}
-");
+                string V_3, //a
+                string V_4,
+                int V_5, //s
+                object V_6,
+                int? V_7)
+  IL_0000:  ldloc.3
+  IL_0001:  ret
+}");
                 VerifyLocal(testData, typeName, locals[3], "<>m3", "s", expectedILOpt:
 @"{
   // Code size        3 (0x3)
@@ -292,13 +283,12 @@ .maxstack  1
   .locals init (object V_0,
                 string V_1,
                 int V_2,
-                object V_3,
-                string V_4, //a
-                string V_5,
-                int V_6, //s
-                object V_7,
-                int? V_8)
-  IL_0000:  ldloc.s    V_6
+                string V_3, //a
+                string V_4,
+                int V_5, //s
+                object V_6,
+                int? V_7)
+  IL_0000:  ldloc.s    V_5
   IL_0002:  ret
 }");
                 locals.Free();
@@ -358,9 +348,8 @@ .locals init (C.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
                 string V_2,
                 int V_3,
                 object V_4,
-                object V_5,
-                int? V_6,
-                System.Action V_7)
+                int? V_5,
+                System.Action V_6)
   IL_0000:  ldarg.0
   IL_0001:  ret
 }");
@@ -373,9 +362,8 @@ .locals init (C.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
                 string V_2,
                 int V_3,
                 object V_4,
-                object V_5,
-                int? V_6,
-                System.Action V_7)
+                int? V_5,
+                System.Action V_6)
   IL_0000:  ldarg.1
   IL_0001:  ret
 }");
@@ -388,14 +376,12 @@ .locals init (C.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
                 string V_2,
                 int V_3,
                 object V_4,
-                object V_5,
-                int? V_6,
-                System.Action V_7)
+                int? V_5,
+                System.Action V_6)
   IL_0000:  ldloc.0
   IL_0001:  ldfld      ""string C.<>c__DisplayClass0_0.a""
   IL_0006:  ret
-}
-");
+}");
                 // We should be able to evaluate "s" within this context, https://github.com/dotnet/roslyn/issues/16594.
 //                VerifyLocal(testData, typeName, locals[3], "<>m3", "s", expectedILOpt:
 //@"{
@@ -435,9 +421,8 @@ .locals init (C.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
                 string V_2,
                 int V_3,
                 object V_4,
-                object V_5,
-                int? V_6,
-                System.Action V_7)
+                int? V_5,
+                System.Action V_6)
   IL_0000:  ldarg.0
   IL_0001:  ret
 }");
@@ -450,9 +435,8 @@ .locals init (C.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
                 string V_2,
                 int V_3,
                 object V_4,
-                object V_5,
-                int? V_6,
-                System.Action V_7)
+                int? V_5,
+                System.Action V_6)
   IL_0000:  ldarg.1
   IL_0001:  ret
 }");
@@ -465,14 +449,12 @@ .locals init (C.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
                 string V_2,
                 int V_3,
                 object V_4,
-                object V_5,
-                int? V_6,
-                System.Action V_7)
+                int? V_5,
+                System.Action V_6)
   IL_0000:  ldloc.0
   IL_0001:  ldfld      ""string C.<>c__DisplayClass0_0.a""
   IL_0006:  ret
-}
-");
+}");
                 // We should be able to evaluate "s" within this context, https://github.com/dotnet/roslyn/issues/16594.
 //                VerifyLocal(testData, typeName, locals[3], "<>m3", "s", expectedILOpt:
 //@"{
@@ -607,13 +589,12 @@ .maxstack  1
   .locals init (int V_0,
                 object V_1,
                 object V_2,
-                object V_3,
-                string V_4,
-                int? V_5,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_6,
-                C.<M>d__1 V_7,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
-                System.Exception V_9)
+                string V_3,
+                int? V_4,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_5,
+                C.<M>d__1 V_6,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_7,
+                System.Exception V_8)
   IL_0000:  ldarg.0
   IL_0001:  ldfld      ""C C.<M>d__1.<>4__this""
   IL_0006:  ret
@@ -625,13 +606,12 @@ .maxstack  1
   .locals init (int V_0,
                 object V_1,
                 object V_2,
-                object V_3,
-                string V_4,
-                int? V_5,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_6,
-                C.<M>d__1 V_7,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
-                System.Exception V_9)
+                string V_3,
+                int? V_4,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_5,
+                C.<M>d__1 V_6,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_7,
+                System.Exception V_8)
   IL_0000:  ldarg.0
   IL_0001:  ldfld      ""object C.<M>d__1.o""
   IL_0006:  ret
@@ -643,13 +623,12 @@ .maxstack  1
   .locals init (int V_0,
                 object V_1,
                 object V_2,
-                object V_3,
-                string V_4,
-                int? V_5,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_6,
-                C.<M>d__1 V_7,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
-                System.Exception V_9)
+                string V_3,
+                int? V_4,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_5,
+                C.<M>d__1 V_6,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_7,
+                System.Exception V_8)
   IL_0000:  ldarg.0
   IL_0001:  ldfld      ""string C.<M>d__1.<a>5__4""
   IL_0006:  ret
@@ -661,13 +640,12 @@ .maxstack  1
   .locals init (int V_0,
                 object V_1,
                 object V_2,
-                object V_3,
-                string V_4,
-                int? V_5,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_6,
-                C.<M>d__1 V_7,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
-                System.Exception V_9)
+                string V_3,
+                int? V_4,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_5,
+                C.<M>d__1 V_6,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_7,
+                System.Exception V_8)
   IL_0000:  ldarg.0
   IL_0001:  ldfld      ""string C.<M>d__1.<s>5__5""
   IL_0006:  ret
@@ -690,13 +668,12 @@ .maxstack  1
   .locals init (int V_0,
                 object V_1,
                 object V_2,
-                object V_3,
-                string V_4,
-                int? V_5,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_6,
-                C.<M>d__1 V_7,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
-                System.Exception V_9)
+                string V_3,
+                int? V_4,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_5,
+                C.<M>d__1 V_6,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_7,
+                System.Exception V_8)
   IL_0000:  ldarg.0
   IL_0001:  ldfld      ""C C.<M>d__1.<>4__this""
   IL_0006:  ret
@@ -708,13 +685,12 @@ .maxstack  1
   .locals init (int V_0,
                 object V_1,
                 object V_2,
-                object V_3,
-                string V_4,
-                int? V_5,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_6,
-                C.<M>d__1 V_7,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
-                System.Exception V_9)
+                string V_3,
+                int? V_4,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_5,
+                C.<M>d__1 V_6,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_7,
+                System.Exception V_8)
   IL_0000:  ldarg.0
   IL_0001:  ldfld      ""object C.<M>d__1.o""
   IL_0006:  ret
@@ -726,13 +702,12 @@ .maxstack  1
   .locals init (int V_0,
                 object V_1,
                 object V_2,
-                object V_3,
-                string V_4,
-                int? V_5,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_6,
-                C.<M>d__1 V_7,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
-                System.Exception V_9)
+                string V_3,
+                int? V_4,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_5,
+                C.<M>d__1 V_6,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_7,
+                System.Exception V_8)
   IL_0000:  ldarg.0
   IL_0001:  ldfld      ""string C.<M>d__1.<a>5__4""
   IL_0006:  ret
@@ -744,13 +719,12 @@ .maxstack  1
   .locals init (int V_0,
                 object V_1,
                 object V_2,
-                object V_3,
-                string V_4,
-                int? V_5,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_6,
-                C.<M>d__1 V_7,
-                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
-                System.Exception V_9)
+                string V_3,
+                int? V_4,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_5,
+                C.<M>d__1 V_6,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_7,
+                System.Exception V_8)
   IL_0000:  ldarg.0
   IL_0001:  ldfld      ""int C.<M>d__1.<s>5__6""
   IL_0006:  ret

From 5b08615a30853298856909d146f5e616b0faba5a Mon Sep 17 00:00:00 2001
From: Jonathon Marolf <jmarolf@microsoft.com>
Date: Wed, 10 May 2017 08:29:50 -0700
Subject: [PATCH 123/284] setting default VB options

---
 build/Targets/Settings.props                         |  3 ++-
 .../Portable/Compilation/VisualBasicCompilation.vb   |  4 ++--
 .../Emit/EditAndContinue/VisualBasicSymbolMatcher.vb |  2 +-
 .../Portable/Symbols/Source/SourceLambdaSymbol.vb    |  2 +-
 .../Portable/Symbols/Source/SourceMethodSymbol.vb    |  2 +-
 .../SynthesizedSymbols/SynthesizedMethodBase.vb      |  2 +-
 .../VisualBasicTest/InteractiveSessionTests.vb       | 12 ++++++------
 src/Scripting/VisualBasicTest/ScriptTests.vb         | 10 +++++-----
 8 files changed, 19 insertions(+), 18 deletions(-)

diff --git a/build/Targets/Settings.props b/build/Targets/Settings.props
index 84a23b39d3a49..c8003a388cbf3 100644
--- a/build/Targets/Settings.props
+++ b/build/Targets/Settings.props
@@ -239,6 +239,7 @@
     <DefineConstants Condition="'$(InitialDefineConstants)' != ''">$(InitialDefineConstants)</DefineConstants>
 
     <!-- The NoWarn property is still being unconditionally set.  https://github.com/dotnet/sdk/issues/752 -->
-    <NoWarn>$(NoWarn);1591</NoWarn>
+    <OptionStrict>Off</OptionStrict>
+    <NoWarn>$(NoWarn);1591;41999;42016</NoWarn>
   </PropertyGroup>
 </Project>
diff --git a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
index 19c0e78b86ca6..3e3947ff04456 100644
--- a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
+++ b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
@@ -245,7 +245,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                             Debug.Assert(tree IsNot VisualBasicSyntaxTree.Dummy)
                             Debug.Assert(tree.IsMyTemplate)
 
-                            Interlocked.CompareExchange(Of SyntaxTree)(_lazyMyTemplate, tree, VisualBasicSyntaxTree.Dummy)
+                            Interlocked.CompareExchange(_lazyMyTemplate, tree, VisualBasicSyntaxTree.Dummy)
                         Else
                             ' we need to make one.
                             Dim text As String = EmbeddedResources.VbMyTemplateText
@@ -260,7 +260,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                 Throw ExceptionUtilities.Unreachable
                             End If
 
-                            If Interlocked.CompareExchange(Of SyntaxTree)(_lazyMyTemplate, tree, VisualBasicSyntaxTree.Dummy) Is VisualBasicSyntaxTree.Dummy Then
+                            If Interlocked.CompareExchange(_lazyMyTemplate, tree, VisualBasicSyntaxTree.Dummy) Is VisualBasicSyntaxTree.Dummy Then
                                 ' set global cache
                                 s_myTemplateCache(parseOptions) = tree
                             End If
diff --git a/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/VisualBasicSymbolMatcher.vb b/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/VisualBasicSymbolMatcher.vb
index 815b55c770ffa..32e5fa5769498 100644
--- a/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/VisualBasicSymbolMatcher.vb
+++ b/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/VisualBasicSymbolMatcher.vb
@@ -134,7 +134,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit
                             typesByName.Add(type.Name, type)
                         End If
                     Next
-                    Interlocked.CompareExchange(Of IReadOnlyDictionary(Of String, Cci.INamespaceTypeDefinition))(Me._lazyTopLevelTypes, typesByName, Nothing)
+                    Interlocked.CompareExchange(Me._lazyTopLevelTypes, typesByName, Nothing)
                 End If
                 Return Me._lazyTopLevelTypes
             End Function
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceLambdaSymbol.vb b/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceLambdaSymbol.vb
index 15b986a2f43a5..8b2c68f7619ea 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceLambdaSymbol.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceLambdaSymbol.vb
@@ -55,7 +55,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
             Get
                 If Me._lazyAnonymousDelegateSymbol Is ErrorTypeSymbol.UnknownResultType Then
                     Dim newValue As NamedTypeSymbol = MakeAssociatedAnonymousDelegate()
-                    Dim oldValue As NamedTypeSymbol = Interlocked.CompareExchange(Of NamedTypeSymbol)(Me._lazyAnonymousDelegateSymbol, newValue, ErrorTypeSymbol.UnknownResultType)
+                    Dim oldValue As NamedTypeSymbol = Interlocked.CompareExchange(Me._lazyAnonymousDelegateSymbol, newValue, ErrorTypeSymbol.UnknownResultType)
                     Debug.Assert(oldValue Is ErrorTypeSymbol.UnknownResultType OrElse oldValue Is newValue)
                 End If
                 Return Me._lazyAnonymousDelegateSymbol
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceMethodSymbol.vb b/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceMethodSymbol.vb
index 6a1a6a0d13c40..b97582748a043 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceMethodSymbol.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceMethodSymbol.vb
@@ -1296,7 +1296,7 @@ lReportErrorOnTwoTokens:
                 meParameter = Nothing
             Else
                 If _lazyMeParameter Is Nothing Then
-                    Interlocked.CompareExchange(Of ParameterSymbol)(_lazyMeParameter, New MeParameterSymbol(Me), Nothing)
+                    Interlocked.CompareExchange(_lazyMeParameter, New MeParameterSymbol(Me), Nothing)
                 End If
 
                 meParameter = _lazyMeParameter
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/SynthesizedSymbols/SynthesizedMethodBase.vb b/src/Compilers/VisualBasic/Portable/Symbols/SynthesizedSymbols/SynthesizedMethodBase.vb
index 5613d3dca11c5..cf7dfb5a7b6b2 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/SynthesizedSymbols/SynthesizedMethodBase.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/SynthesizedSymbols/SynthesizedMethodBase.vb
@@ -178,7 +178,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
                 meParameter = Nothing
             Else
                 If _lazyMeParameter Is Nothing Then
-                    Interlocked.CompareExchange(Of ParameterSymbol)(_lazyMeParameter, New MeParameterSymbol(Me), Nothing)
+                    Interlocked.CompareExchange(_lazyMeParameter, New MeParameterSymbol(Me), Nothing)
                 End If
 
                 meParameter = _lazyMeParameter
diff --git a/src/Scripting/VisualBasicTest/InteractiveSessionTests.vb b/src/Scripting/VisualBasicTest/InteractiveSessionTests.vb
index ffafd0c97a97d..67e2bb07062b2 100644
--- a/src/Scripting/VisualBasicTest/InteractiveSessionTests.vb
+++ b/src/Scripting/VisualBasicTest/InteractiveSessionTests.vb
@@ -19,7 +19,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Scripting.UnitTests
                 ContinueWith("Dim y As Integer = 2").
                 ContinueWith("?x + y")
 
-            Assert.Equal(3, CType(s.ReturnValue, Integer))
+            Assert.Equal(3, s.ReturnValue)
         End Function
 
         <Fact>
@@ -27,7 +27,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Scripting.UnitTests
             Dim source = "
 ?1 _
 "
-            Assert.Equal(1, CType(VisualBasicScript.EvaluateAsync(source).Result, Integer))
+            Assert.Equal(1, VisualBasicScript.EvaluateAsync(source).Result)
         End Sub
 
         <Fact>
@@ -35,7 +35,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Scripting.UnitTests
             Dim source = "
 ?1
 "
-            Assert.Equal(1, CType(VisualBasicScript.EvaluateAsync(source).Result, Integer))
+            Assert.Equal(1, VisualBasicScript.EvaluateAsync(source).Result)
         End Sub
 
         <Fact>
@@ -61,7 +61,7 @@ End If
 ?x + 1
 "
 
-            Assert.Equal(6, CType(VisualBasicScript.EvaluateAsync(source).Result, Integer))
+            Assert.Equal(6, VisualBasicScript.EvaluateAsync(source).Result)
         End Sub
 
         <Fact>
@@ -81,7 +81,7 @@ Dim d = New With { Key .F = 777 }
     & "" "" & (a.GetType() Is b.GetType()).ToString() _
     & "" "" & (b.GetType() is d.GetType()).ToString()
 ")
-            Assert.Equal("True False True", CType(script.EvaluateAsync().Result, String))
+            Assert.Equal("True False True", script.EvaluateAsync().Result)
         End Sub
 
         <Fact>
@@ -107,7 +107,7 @@ Dim d = Function () As Integer
     & "" "" & (b.GetType() is d.GetType()).ToString()
 ")
 
-            Assert.Equal("True False True", CType(script.EvaluateAsync().Result, String))
+            Assert.Equal("True False True", script.EvaluateAsync().Result)
         End Sub
     End Class
 
diff --git a/src/Scripting/VisualBasicTest/ScriptTests.vb b/src/Scripting/VisualBasicTest/ScriptTests.vb
index 135694269fbaf..e64264a006757 100644
--- a/src/Scripting/VisualBasicTest/ScriptTests.vb
+++ b/src/Scripting/VisualBasicTest/ScriptTests.vb
@@ -22,14 +22,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Scripting.UnitTests
 
         <Fact>
         Public Sub TestEvalScript()
-            Dim value = CType(VisualBasicScript.EvaluateAsync("? 1 + 2", s_defaultOptions).Result, Integer)
-            Assert.Equal(3, value)
+            Dim value = VisualBasicScript.EvaluateAsync("? 1 + 2", s_defaultOptions)
+            Assert.Equal(3, value.Result)
         End Sub
 
         <Fact>
         Public Async Function TestRunScript() As Task
             Dim state = Await VisualBasicScript.RunAsync("? 1 + 2", s_defaultOptions)
-            Assert.Equal(3, CType(state.ReturnValue, Integer))
+            Assert.Equal(3, state.ReturnValue)
         End Function
 
         <Fact>
@@ -37,13 +37,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Scripting.UnitTests
             Dim script = VisualBasicScript.Create("? 1 + 2", s_defaultOptions)
             Dim state = Await script.RunAsync()
             Assert.Same(script, state.Script)
-            Assert.Equal(3, CType(state.ReturnValue, Integer))
+            Assert.Equal(3, state.ReturnValue)
         End Function
 
         <Fact>
         Public Async Function TestRunScriptWithSpecifiedReturnType() As Task
             Dim state = Await VisualBasicScript.RunAsync("? 1 + 2", s_defaultOptions)
-            Assert.Equal(3, CType(state.ReturnValue, Integer))
+            Assert.Equal(3, state.ReturnValue)
         End Function
 
         <Fact>

From 1c66e3360b0c5f26776b66016dee89d7a4bf5a3f Mon Sep 17 00:00:00 2001
From: Jonathon Marolf <jmarolf@microsoft.com>
Date: Wed, 10 May 2017 12:26:48 -0700
Subject: [PATCH 124/284] setting option strict to on

---
 build/Targets/Settings.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build/Targets/Settings.props b/build/Targets/Settings.props
index c8003a388cbf3..8f67e75586ff8 100644
--- a/build/Targets/Settings.props
+++ b/build/Targets/Settings.props
@@ -239,7 +239,7 @@
     <DefineConstants Condition="'$(InitialDefineConstants)' != ''">$(InitialDefineConstants)</DefineConstants>
 
     <!-- The NoWarn property is still being unconditionally set.  https://github.com/dotnet/sdk/issues/752 -->
-    <OptionStrict>Off</OptionStrict>
+    <OptionStrict>On</OptionStrict>
     <NoWarn>$(NoWarn);1591;41999;42016</NoWarn>
   </PropertyGroup>
 </Project>

From 3527fbb4f1509eef5359dd02e845e9a8268f567b Mon Sep 17 00:00:00 2001
From: Jonathon Marolf <jmarolf@microsoft.com>
Date: Wed, 10 May 2017 13:04:42 -0700
Subject: [PATCH 125/284] removing no warn for type conversions

---
 build/Targets/Settings.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build/Targets/Settings.props b/build/Targets/Settings.props
index 8f67e75586ff8..9e4567f567f03 100644
--- a/build/Targets/Settings.props
+++ b/build/Targets/Settings.props
@@ -240,6 +240,6 @@
 
     <!-- The NoWarn property is still being unconditionally set.  https://github.com/dotnet/sdk/issues/752 -->
     <OptionStrict>On</OptionStrict>
-    <NoWarn>$(NoWarn);1591;41999;42016</NoWarn>
+    <NoWarn>$(NoWarn);1591</NoWarn>
   </PropertyGroup>
 </Project>

From b0249eef9b8ef140dedc20d83c06e6c1ba36023e Mon Sep 17 00:00:00 2001
From: Ty Overby <ty@pre-alpha.com>
Date: Thu, 11 May 2017 09:09:10 -0700
Subject: [PATCH 126/284] Remove remaining prototype comments (#19392)

* remove remaining prototype comments, add extension method tests

* fix old test, address review feedback

* ReturnType implemented on each subclass

* added more tests on non-async task returning mains

* add obsolete tests

* autoformat

* add better tests for successful task overrides
---
 .../Portable/Compilation/CSharpCompilation.cs |   4 +-
 .../Portable/Compiler/MethodCompiler.cs       |  39 ++-
 .../SynthesizedEntryPointSymbol.cs            |  36 ++-
 .../Emit/CodeGen/CodeGenAsyncMainTests.cs     | 295 ++++++++++++++++--
 .../Semantic/Semantics/BindingAsyncTests.cs   |   6 +-
 5 files changed, 328 insertions(+), 52 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index 9e078424051a2..b64ffb101ed45 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
@@ -1512,9 +1512,8 @@ bool CheckValid(MethodSymbol candidate, bool isCandidate, DiagnosticBag specific
                 {
                     foreach (var (IsValid, Candidate, SpecificDiagnostics) in taskEntryPoints)
                     {
-                        // PROTOTYPE(async-main): Get the diagnostic to point to a smaller syntax piece.
                         if (CheckValid(Candidate, IsValid, SpecificDiagnostics) &&
-                            CheckFeatureAvailability(Candidate.GetNonNullSyntaxNode(), MessageID.IDS_FeatureAsyncMain, diagnostics))
+                            CheckFeatureAvailability(Candidate.ExtractReturnTypeSyntax(), MessageID.IDS_FeatureAsyncMain, diagnostics))
                         {
                             diagnostics.AddRange(SpecificDiagnostics);
                             viableEntryPoints.Add(Candidate);
@@ -1611,7 +1610,6 @@ internal bool ReturnsAwaitableToVoidOrInt(MethodSymbol method, DiagnosticBag dia
 
             var syntax = method.ExtractReturnTypeSyntax();
             var dumbInstance = new BoundLiteral(syntax, ConstantValue.Null, method.ReturnType);
-            // PROTOTYPE(async-main): We might need to adjust the containing member of the binder to be the Main method
             var binder = GetBinder(syntax);
             BoundExpression result;
             var success = binder.GetAwaitableExpressionInfo(dumbInstance, out _, out _, out _, out result, syntax, diagnostics);
diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
index 731985d09b33f..d16155984fb51 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
@@ -206,9 +206,9 @@ private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModul
 
             // entryPoint can be a SynthesizedEntryPointSymbol if a script is being compiled.
             SynthesizedEntryPointSymbol synthesizedEntryPoint = entryPoint as SynthesizedEntryPointSymbol;
-            if ((object)synthesizedEntryPoint == null && compilation.ReturnsAwaitableToVoidOrInt(entryPoint, diagnostics))
+            if ((object)synthesizedEntryPoint == null && (entryPoint.ReturnType.IsGenericTaskType(compilation) || entryPoint.ReturnType.IsNonGenericTaskType(compilation)))
             {
-                synthesizedEntryPoint = new SynthesizedEntryPointSymbol.AsyncForwardEntryPoint(compilation, diagnostics, entryPoint.ContainingType, entryPoint);
+                synthesizedEntryPoint = new SynthesizedEntryPointSymbol.AsyncForwardEntryPoint(compilation, entryPoint.ContainingType, entryPoint);
                 entryPoint = synthesizedEntryPoint;
                 if ((object)moduleBeingBuilt != null)
                 {
@@ -221,13 +221,44 @@ private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModul
                 !hasDeclarationErrors &&
                 !diagnostics.HasAnyErrors())
             {
-                var body = synthesizedEntryPoint.CreateBody();
+                BoundStatement body = synthesizedEntryPoint.CreateBody();
+
+                var dynamicAnalysisSpans = ImmutableArray<SourceSpan>.Empty;
+                VariableSlotAllocator lazyVariableSlotAllocator = null;
+                var lambdaDebugInfoBuilder = ArrayBuilder<LambdaDebugInfo>.GetInstance();
+                var closureDebugInfoBuilder = ArrayBuilder<ClosureDebugInfo>.GetInstance();
+                StateMachineTypeSymbol stateMachineTypeOpt = null;
                 const int methodOrdinal = -1;
+
+                var loweredBody = LowerBodyOrInitializer(
+                    synthesizedEntryPoint,
+                    methodOrdinal,
+                    body,
+                    null,
+                    new TypeCompilationState(synthesizedEntryPoint.ContainingType, compilation, moduleBeingBuilt),
+                    false,
+                    null,
+                    ref dynamicAnalysisSpans,
+                    diagnostics,
+                    ref lazyVariableSlotAllocator,
+                    lambdaDebugInfoBuilder,
+                    closureDebugInfoBuilder,
+                    out stateMachineTypeOpt);
+
+                Debug.Assert((object)lazyVariableSlotAllocator == null);
+                Debug.Assert((object)stateMachineTypeOpt == null);
+                Debug.Assert(dynamicAnalysisSpans.IsEmpty);
+                Debug.Assert(lambdaDebugInfoBuilder.IsEmpty());
+                Debug.Assert(closureDebugInfoBuilder.IsEmpty());
+
+                lambdaDebugInfoBuilder.Free();
+                closureDebugInfoBuilder.Free();
+
                 var emittedBody = GenerateMethodBody(
                     moduleBeingBuilt,
                     synthesizedEntryPoint,
                     methodOrdinal,
-                    body,
+                    loweredBody,
                     ImmutableArray<LambdaDebugInfo>.Empty,
                     ImmutableArray<ClosureDebugInfo>.Empty,
                     stateMachineTypeOpt: null,
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
index 826b6d3ae3d80..7dff9eb3426f5 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
@@ -19,8 +19,6 @@ internal abstract class SynthesizedEntryPointSymbol : MethodSymbol
         internal const string FactoryName = "<Factory>";
 
         private readonly NamedTypeSymbol _containingType;
-        // PROTOTYPE(async-main): remove this and move it out into inheriting classes?
-        private TypeSymbol _returnType;
 
         internal static SynthesizedEntryPointSymbol Create(SynthesizedInteractiveInitializerMethod initializerMethod, DiagnosticBag diagnostics)
         {
@@ -57,12 +55,11 @@ internal static SynthesizedEntryPointSymbol Create(SynthesizedInteractiveInitial
             }
         }
 
-        private SynthesizedEntryPointSymbol(NamedTypeSymbol containingType, TypeSymbol returnType = null)
+        private SynthesizedEntryPointSymbol(NamedTypeSymbol containingType)
         {
             Debug.Assert((object)containingType != null);
 
             _containingType = containingType;
-            _returnType = returnType;
         }
 
         internal override bool GenerateDebugInfo
@@ -130,11 +127,6 @@ internal override RefKind RefKind
             get { return RefKind.None; }
         }
 
-        public override TypeSymbol ReturnType
-        {
-            get { return _returnType; }
-        }
-
         public override ImmutableArray<CustomModifier> ReturnTypeCustomModifiers
         {
             get { return ImmutableArray<CustomModifier>.Empty; }
@@ -162,7 +154,7 @@ public override int Arity
 
         public override bool ReturnsVoid
         {
-            get { return _returnType.SpecialType == SpecialType.System_Void; }
+            get { return ReturnType.SpecialType == SpecialType.System_Void; }
         }
 
         public override MethodKind MethodKind
@@ -341,7 +333,7 @@ internal sealed class AsyncForwardEntryPoint : SynthesizedEntryPointSymbol
 
             private readonly ImmutableArray<ParameterSymbol> _parameters;
 
-            internal AsyncForwardEntryPoint(CSharpCompilation compilation, DiagnosticBag diagnosticBag, NamedTypeSymbol containingType, MethodSymbol userMain) :
+            internal AsyncForwardEntryPoint(CSharpCompilation compilation, NamedTypeSymbol containingType, MethodSymbol userMain) :
                 base(containingType)
             {
                 // There should be no way for a userMain to be passed in unless it already passed the 
@@ -349,7 +341,6 @@ internal AsyncForwardEntryPoint(CSharpCompilation compilation, DiagnosticBag dia
                 Debug.Assert(userMain.ParameterCount == 0 || userMain.ParameterCount == 1);
 
                 _userMainReturnTypeSyntax = userMain.ExtractReturnTypeSyntax();
-                // PROTOTYPE(async-main): we might need to adjust the containing member of the binder to be the Main method.
                 var binder = compilation.GetBinder(_userMainReturnTypeSyntax);
                 _parameters = SynthesizedParameterSymbol.DeriveParameters(userMain, this);
 
@@ -371,9 +362,10 @@ internal AsyncForwardEntryPoint(CSharpCompilation compilation, DiagnosticBag dia
                         type: userMain.ReturnType)
                 { WasCompilerGenerated = true };
 
-                // PROTOTYPE(async-main): lower the tree.
-                var success = binder.GetAwaitableExpressionInfo(userMainInvocation, out _, out _, out _, out _getAwaiterGetResultCall, _userMainReturnTypeSyntax, diagnosticBag);
-                _returnType = _getAwaiterGetResultCall.Type;
+                // The diagnostics that would be produced here will already have been captured and returned.
+                var droppedBag = DiagnosticBag.GetInstance();
+                var success = binder.GetAwaitableExpressionInfo(userMainInvocation, out _, out _, out _, out _getAwaiterGetResultCall, _userMainReturnTypeSyntax, droppedBag);
+                droppedBag.Free();
 
                 Debug.Assert(
                     ReturnType.SpecialType == SpecialType.System_Void ||
@@ -384,6 +376,8 @@ internal AsyncForwardEntryPoint(CSharpCompilation compilation, DiagnosticBag dia
 
             public override ImmutableArray<ParameterSymbol> Parameters => _parameters;
 
+            public override TypeSymbol ReturnType => _getAwaiterGetResultCall.Type;
+
             internal override BoundBlock CreateBody()
             {
                 var syntax = _userMainReturnTypeSyntax;
@@ -432,21 +426,25 @@ private sealed class ScriptEntryPoint : SynthesizedEntryPointSymbol
         {
             private readonly MethodSymbol _getAwaiterMethod;
             private readonly MethodSymbol _getResultMethod;
+            private readonly TypeSymbol _returnType;
 
             internal ScriptEntryPoint(NamedTypeSymbol containingType, TypeSymbol returnType, MethodSymbol getAwaiterMethod, MethodSymbol getResultMethod) :
-                base(containingType, returnType)
+                base(containingType)
             {
                 Debug.Assert(containingType.IsScriptClass);
                 Debug.Assert(returnType.SpecialType == SpecialType.System_Void);
 
                 _getAwaiterMethod = getAwaiterMethod;
                 _getResultMethod = getResultMethod;
+                _returnType = returnType;
             }
 
             public override string Name => MainName;
 
             public override ImmutableArray<ParameterSymbol> Parameters => ImmutableArray<ParameterSymbol>.Empty;
 
+            public override TypeSymbol ReturnType => _returnType;
+
             // private static void <Main>()
             // {
             //     var script = new Script();
@@ -516,13 +514,15 @@ internal override BoundBlock CreateBody()
         private sealed class SubmissionEntryPoint : SynthesizedEntryPointSymbol
         {
             private readonly ImmutableArray<ParameterSymbol> _parameters;
+            private readonly TypeSymbol _returnType;
 
             internal SubmissionEntryPoint(NamedTypeSymbol containingType, TypeSymbol returnType, TypeSymbol submissionArrayType) :
-                base(containingType, returnType)
+                base(containingType)
             {
                 Debug.Assert(containingType.IsSubmissionClass);
                 Debug.Assert(returnType.SpecialType != SpecialType.System_Void);
                 _parameters = ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, submissionArrayType, 0, RefKind.None, "submissionArray"));
+                _returnType = returnType;
             }
 
             public override string Name
@@ -535,6 +535,8 @@ public override ImmutableArray<ParameterSymbol> Parameters
                 get { return _parameters; }
             }
 
+            public override TypeSymbol ReturnType => _returnType;
+
             // private static T <Factory>(object[] submissionArray) 
             // {
             //     var submission = new Submission#N(submissionArray);
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMainTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMainTests.cs
index fbaae3a50786b..34bd9f103093a 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMainTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncMainTests.cs
@@ -658,14 +658,33 @@ async static Task Main(string[] args)
 }";
             var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
             compilation.VerifyDiagnostics(
-                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
-                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1),
-                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                // (6,18): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
                 //     async static Task Main(string[] args)
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task Main(string[] args)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, "Task").WithArguments("async main", "7.1").WithLocation(6, 18),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void MainCantBeAsyncWithArgs_CSharp7_NoAwait()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static Task Main(string[] args)
     {
-        await Task.Factory.StartNew(() => { });
-    }").WithArguments("async main", "7.1").WithLocation(6, 5));
+        return Task.Factory.StartNew(() => { });
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            compilation.VerifyDiagnostics(
+                // (6,18): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     async static Task Main(string[] args)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, "Task").WithArguments("async main", "7.1").WithLocation(6, 12),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
         }
 
         [Fact]
@@ -836,14 +855,33 @@ async static Task<int> Main(string[] args)
 }";
             var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
             compilation.VerifyDiagnostics(
-            // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
-            Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1),
-            // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
-            //     async static Task<int> Main(string[] args)
-            Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task<int> Main(string[] args)
+                // (6,18): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     async static Task<int> Main(string[] args)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, "Task<int>").WithArguments("async main", "7.1").WithLocation(6, 18),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void MainCantBeAsyncAndGenericOnInt_WithArgs_Csharp7_NoAsync()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static Task<int> Main(string[] args)
     {
-        return await Task.Factory.StartNew(() => 5);
-    }").WithArguments("async main", "7.1").WithLocation(6, 5));
+        return Task.Factory.StartNew(() => 5);
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            compilation.VerifyDiagnostics(
+                // (6,18): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     async static Task<int> Main(string[] args)
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, "Task<int>").WithArguments("async main", "7.1").WithLocation(6, 12),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
         }
 
         [Fact]
@@ -901,12 +939,31 @@ async static Task<int> Main()
 }";
             var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
             compilation.VerifyDiagnostics(
-                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                // (6,18): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
                 //     async static Task<int> Main()
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task<int> Main()
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, "Task<int>").WithArguments("async main", "7.1").WithLocation(6, 18),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void MainCantBeAsyncAndGenericOnInt_CSharp7_NoAsync()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static Task<int> Main()
     {
-        return await Task.Factory.StartNew(() => 5);
-    }").WithArguments("async main", "7.1").WithLocation(6, 5),
+        return Task.Factory.StartNew(() => 5);
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7));
+            compilation.VerifyDiagnostics(
+                // (6,18): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     async static Task<int> Main()
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, "Task<int>").WithArguments("async main", "7.1").WithLocation(6, 12),
                 // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
                 Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
         }
@@ -1146,13 +1203,9 @@ async static Task<float> Main(string[] args)
                 // (12,30): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
                 //     async static Task<float> Main(string[] args)
                 Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "Main").WithLocation(12, 30),
-                // (6,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                // (6,18): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
                 //     async static Task<int> Main()
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async static Task<int> Main()
-    {
-        System.Console.WriteLine(""Task<int>"");
-        return 0;
-    }").WithArguments("async main", "7.1").WithLocation(6, 5),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, "Task<int>").WithArguments("async main", "7.1").WithLocation(6, 18),
                 // (12,30): warning CS0028: 'A.Main(string[])' has the wrong signature to be an entry point
                 //     async static Task<float> Main(string[] args)
                 Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main(string[])").WithLocation(12, 30),
@@ -1160,6 +1213,36 @@ async static Task<float> Main(string[] args)
                 Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
         }
 
+        [Fact]
+        public void TaskIntAndTaskFloat_CSharp7_NoAsync()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+class A
+{
+    static Task<int> Main()
+    {
+        System.Console.WriteLine(""Task<int>"");
+        return Task.FromResult(0);
+    }
+
+    static Task<float> Main(string[] args)
+    {
+        System.Console.WriteLine(""Task<float>"");
+        return Task.FromResult(0.0F);
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseDebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7)).VerifyDiagnostics(
+                // (6,12): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                //     static Task<int> Main()
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, "Task<int>").WithArguments("async main", "7.1").WithLocation(6, 12),
+                // (12,24): warning CS0028: 'A.Main(string[])' has the wrong signature to be an entry point
+                //     static Task<float> Main(string[] args)
+                Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main(string[])").WithLocation(12, 24),
+                // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
+                Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
+        }
 
         [Fact]
         public void TaskOfFloatMainAndNonTaskMain()
@@ -1185,7 +1268,7 @@ async static Task<float> Main(string[] args)
                 // (10,30): warning CS0028: 'A.Main(string[])' has the wrong signature to be an entry point
                 //     async static Task<float> Main(string[] args)
                 Diagnostic(ErrorCode.WRN_InvalidMainSig, "Main").WithArguments("A.Main(string[])").WithLocation(11, 30));
-                CompileAndVerify(compilation, expectedOutput: "Non Task Main", expectedReturnCode: 0);
+            CompileAndVerify(compilation, expectedOutput: "Non Task Main", expectedReturnCode: 0);
         }
 
         [Fact]
@@ -1211,5 +1294,169 @@ async static Task<float> Main(string[] args)
             var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe.WithMainTypeName("A")).VerifyDiagnostics();
             CompileAndVerify(compilation, expectedOutput: "Non Task Main", expectedReturnCode: 0);
         }
+
+        [Fact]
+        public void ImplementGetAwaiterGetResultViaExtensionMethods()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+namespace System.Runtime.CompilerServices {
+    public class ExtensionAttribute {}
+}
+
+namespace System.Runtime.CompilerServices {
+    public interface INotifyCompletion {
+        void OnCompleted(Action action);
+    }
+}
+
+namespace System.Threading.Tasks {
+    public class Awaiter: System.Runtime.CompilerServices.INotifyCompletion {
+        public bool IsCompleted  => true;
+        public void OnCompleted(Action action) {}
+        public void GetResult() {
+            System.Console.Write(""GetResult called"");
+        }
+    }
+    public class Task {}
+}
+
+public static class MyExtensions {
+    public static Awaiter GetAwaiter(this Task task) {
+        System.Console.Write(""GetAwaiter called | "");
+        return new Awaiter();
+    }
+}
+
+static class Program {
+    static Task Main() {
+        return new Task();
+    }
+}";
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            var verifier = sourceCompilation.VerifyEmitDiagnostics(
+                // (26,43): warning CS0436: The type 'Task' in '' conflicts with the imported type 'Task' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     public static Awaiter GetAwaiter(this Task task) {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task").WithArguments("", "System.Threading.Tasks.Task", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task").WithLocation(26, 43),
+                // (33,12): warning CS0436: The type 'Task' in '' conflicts with the imported type 'Task' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     static Task Main() {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task").WithArguments("", "System.Threading.Tasks.Task", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task").WithLocation(33, 12),
+                // (34,20): warning CS0436: The type 'Task' in '' conflicts with the imported type 'Task' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //         return new Task();
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task").WithArguments("", "System.Threading.Tasks.Task", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task").WithLocation(34, 20));
+            CompileAndVerify(sourceCompilation, expectedOutput: "GetAwaiter called | GetResult called");
+        }
+
+        [Fact]
+        public void ImplementGetAwaiterGetResultViaExtensionMethods_Obsolete()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+namespace System.Runtime.CompilerServices {
+    public class ExtensionAttribute {}
+}
+
+namespace System.Runtime.CompilerServices {
+    public interface INotifyCompletion {
+        void OnCompleted(Action action);
+    }
+}
+
+namespace System.Threading.Tasks {
+    public class Awaiter: System.Runtime.CompilerServices.INotifyCompletion {
+        public bool IsCompleted  => true;
+        public void OnCompleted(Action action) {}
+        public void GetResult() {
+            System.Console.Write(""GetResult called"");
+        }
+    }
+    public class Task {}
+}
+
+public static class MyExtensions {
+    [System.Obsolete(""test"")]
+    public static Awaiter GetAwaiter(this Task task) {
+        System.Console.Write(""GetAwaiter called | "");
+        return new Awaiter();
+    }
+}
+
+static class Program {
+    static Task Main() {
+        return new Task();
+    }
+}";
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            var verifier = sourceCompilation.VerifyEmitDiagnostics(
+                // (34,12): warning CS0436: The type 'Task' in '' conflicts with the imported type 'Task' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     static Task Main() {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task").WithArguments("", "System.Threading.Tasks.Task", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task").WithLocation(34, 12),
+                // (27,43): warning CS0436: The type 'Task' in '' conflicts with the imported type 'Task' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     public static Awaiter GetAwaiter(this Task task) {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task").WithArguments("", "System.Threading.Tasks.Task", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task").WithLocation(27, 43),
+                // (35,20): warning CS0436: The type 'Task' in '' conflicts with the imported type 'Task' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //         return new Task();
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task").WithArguments("", "System.Threading.Tasks.Task", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task").WithLocation(35, 20),
+                // (34,12): warning CS0618: 'MyExtensions.GetAwaiter(Task)' is obsolete: 'test'
+                //     static Task Main() {
+                Diagnostic(ErrorCode.WRN_DeprecatedSymbolStr, "Task").WithArguments("MyExtensions.GetAwaiter(System.Threading.Tasks.Task)", "test").WithLocation(34, 12));
+
+            CompileAndVerify(sourceCompilation, expectedOutput: "GetAwaiter called | GetResult called");
+        }
+
+        [Fact]
+        public void ImplementGetAwaiterGetResultViaExtensionMethods_ObsoleteFailing()
+        {
+            var source = @"
+using System.Threading.Tasks;
+
+namespace System.Runtime.CompilerServices {
+    public class ExtensionAttribute {}
+}
+
+namespace System.Runtime.CompilerServices {
+    public interface INotifyCompletion {
+        void OnCompleted(Action action);
+    }
+}
+
+namespace System.Threading.Tasks {
+    public class Awaiter: System.Runtime.CompilerServices.INotifyCompletion {
+        public bool IsCompleted  => true;
+        public void OnCompleted(Action action) {}
+        public void GetResult() {}
+    }
+    public class Task {}
+}
+
+public static class MyExtensions {
+    [System.Obsolete(""test"", true)]
+    public static Awaiter GetAwaiter(this Task task) {
+        return null;
+    }
+}
+
+static class Program {
+    static Task Main() {
+        return new Task();
+    }
+}";
+            var sourceCompilation = CreateStandardCompilation(source, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));
+            var verifier = sourceCompilation.VerifyEmitDiagnostics(
+                // (25,43): warning CS0436: The type 'Task' in '' conflicts with the imported type 'Task' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     public static Awaiter GetAwaiter(this Task task) {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task").WithArguments("", "System.Threading.Tasks.Task", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task").WithLocation(25, 43),
+                // (31,12): warning CS0436: The type 'Task' in '' conflicts with the imported type 'Task' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //     static Task Main() {
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task").WithArguments("", "System.Threading.Tasks.Task", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task").WithLocation(31, 12),
+                // (32,20): warning CS0436: The type 'Task' in '' conflicts with the imported type 'Task' in 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. Using the type defined in ''.
+                //         return new Task();
+                Diagnostic(ErrorCode.WRN_SameFullNameThisAggAgg, "Task").WithArguments("", "System.Threading.Tasks.Task", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Threading.Tasks.Task").WithLocation(32, 20),
+                // (31,12): warning CS0618: 'MyExtensions.GetAwaiter(Task)' is obsolete: 'test'
+                //     static Task Main() {
+                Diagnostic(ErrorCode.ERR_DeprecatedSymbolStr, "Task").WithArguments("MyExtensions.GetAwaiter(System.Threading.Tasks.Task)", "test").WithLocation(31, 12));
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs
index b5ceade1893ea..8ca2ec00d7152 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTests.cs
@@ -3434,11 +3434,9 @@ async public static Task Main()
                 // (5,30): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
                 //     async public static Task Main()
                 Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "Main").WithLocation(5, 30),
-                // (5,5): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
+                // (5,25): error CS8107: Feature 'async main' is not available in C# 7. Please use language version 7.1 or greater.
                 //     async public static Task Main()
-                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, @"async public static Task Main()
-    {
-    }").WithArguments("async main", "7.1").WithLocation(5, 5),
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7, "Task").WithArguments("async main", "7.1").WithLocation(5, 25),
                 // error CS5001: Program does not contain a static 'Main' method suitable for an entry point
                 Diagnostic(ErrorCode.ERR_NoEntryPoint).WithLocation(1, 1));
         }

From 459949935b16734af5acbf4c8a69c5084b195ce1 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Wed, 10 May 2017 17:42:19 -0700
Subject: [PATCH 127/284] Added initial user filtering

---
 .../TestHooks/FeatureAttribute_Names.cs       |   1 +
 .../AnalyzerVsixSuggestedActionCallback.cs    | 174 +++++++++++++++++-
 .../Core/Def/ServicesVSResources.Designer.cs  |   9 +
 .../Core/Def/ServicesVSResources.resx         |   3 +
 4 files changed, 178 insertions(+), 9 deletions(-)

diff --git a/src/Features/Core/Portable/Shared/TestHooks/FeatureAttribute_Names.cs b/src/Features/Core/Portable/Shared/TestHooks/FeatureAttribute_Names.cs
index d91c697922975..43df164421c7b 100644
--- a/src/Features/Core/Portable/Shared/TestHooks/FeatureAttribute_Names.cs
+++ b/src/Features/Core/Portable/Shared/TestHooks/FeatureAttribute_Names.cs
@@ -4,6 +4,7 @@ namespace Microsoft.CodeAnalysis.Shared.TestHooks
 {
     internal partial class FeatureAttribute
     {
+        public const string ABTest = nameof(ABTest);
         public const string AutomaticEndConstructCorrection = nameof(AutomaticEndConstructCorrection);
         public const string AutomaticPairCompletion = nameof(AutomaticPairCompletion);
         public const string BraceHighlighting = nameof(BraceHighlighting);
diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
index 25430d51d5538..dbd047418dbe9 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -1,39 +1,163 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Generic;
 using System.ComponentModel.Composition;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Implementation.Suggestions;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Experiments;
 using Microsoft.CodeAnalysis.Extensions;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.Experimentation
 {
     [Export(typeof(ISuggestedActionCallback))]
-    class AnalyzerVsixSuggestedActionCallback : ISuggestedActionCallback
+    internal class AnalyzerVsixSuggestedActionCallback : ForegroundThreadAffinitizedObject, ISuggestedActionCallback
     {
         private const string AnalyzerEnabledFlight = @"LiveCA/LiveCAcf";
         private const string AnalyzerVsixHyperlink = @"https://aka.ms/livecodeanalysis";
 
         private readonly VisualStudioWorkspace _workspace;
-        private readonly IInfoBarService _infoBarService;
+        private readonly IForegroundNotificationService _foregroundNotificationService;
+        private readonly IAsynchronousOperationListener _operationListener;
+
+        private readonly object _scheduleLock = new object();
+        private bool _checksRunning = false;
 
         [ImportingConstructor]
-        public AnalyzerVsixSuggestedActionCallback(IInfoBarService infoBarService, VisualStudioWorkspace workspace)
+        public AnalyzerVsixSuggestedActionCallback(VisualStudioWorkspace workspace,
+            IForegroundNotificationService foregroundNotificationService,
+            [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners)
         {
             _workspace = workspace;
-            _infoBarService = infoBarService;
+            _foregroundNotificationService = foregroundNotificationService;
+            _operationListener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.ABTest);
         }
 
         public void OnSuggestedActionExecuted(SuggestedAction action)
         {
+            AssertIsForeground();
+
+            lock (_scheduleLock)
+            {
+                if (!_checksRunning)
+                {
+                    _checksRunning = true;
+                    Task.Run((Action)SuggestedActionOccurred);
+                }
+            }
+        }
+
+        private void SuggestedActionOccurred()
+        {
+            // We don't need to do this work on the UI thread
+            AssertIsBackground();
+
+            var options = _workspace.Options;
+
+            // If the user has previously clicked don't show again, then we bail out immediately
+            if (options.GetOption(AnalyzerABTestOptions.NeverShowAgain))
+            {
+                // We purposefully do not set _checksRunning back to false. That way, we'll never check again this session
+                return;
+            }
+
+            // Filter for valid A/B test candidates. Candidates fill the following critera:
+            //     1: Are a Dotnet user (as evidenced by the fact that this code is being run)
+            //     2: Have triggered a lightbulb on 3 separate days
+
+            // If the user hasn't met candidacy conditions, then we check them. Otherwise, proceed to info bar check
+            var isCandidate = options.GetOption(AnalyzerABTestOptions.HasMetCandidacyRequirements);
+            if (!isCandidate)
+            {
+                // We store in UTC to avoid any timezone offset weirdness
+                var lastTriggeredTime = DateTime.FromBinary(options.GetOption(AnalyzerABTestOptions.LastDayUsedSuggestionAction));
+                var currentTime = DateTime.UtcNow;
+                var span = currentTime - lastTriggeredTime;
+                if (span.TotalDays >= 1)
+                {
+                    options = options.WithChangedOption(AnalyzerABTestOptions.LastDayUsedSuggestionAction, currentTime.ToBinary());
+                    var usageCount = options.GetOption(AnalyzerABTestOptions.UsedSuggestedActionCount);
+                    usageCount++;
+                    options = options.WithChangedOption(AnalyzerABTestOptions.UsedSuggestedActionCount, usageCount);
+
+                    if (usageCount >= 3)
+                    {
+                        isCandidate = true;
+                        options = options.WithChangedOption(AnalyzerABTestOptions.HasMetCandidacyRequirements, true);
+                    }
+                    _workspace.Options = options;
+                }
+            }
+
+            // If the user still isn't a candidate, then return. Otherwise, we move to checking if the infobar should be shown
+            if (!isCandidate)
+            {
+                lock (_scheduleLock)
+                {
+                    _checksRunning = false;
+                }
+
+                return;
+            }
+
+            // Queue the show notification bar to the UI thread. This will set _checksRunning back to true after it has shown the infobar
+            _foregroundNotificationService.RegisterNotification((Action)ShowInfoBarIfNecessary,
+                _operationListener.BeginAsyncOperation(nameof(ShowInfoBarIfNecessary)));
+        }
+
+        private void ShowInfoBarIfNecessary()
+        {
+            // We can only get the experimentation service on the UI thread
+            AssertIsForeground();
+
             var experimentationService = _workspace.Services.GetRequiredService<IExperimentationService>();
             if (experimentationService.IsExperimentEnabled(AnalyzerEnabledFlight))
             {
-                _infoBarService.ShowInfoBarInGlobalView(
-                    ServicesVSResources.Analyzer_vsix_try_description,
-                    new InfoBarUI(title: ServicesVSResources.Analyzer_vsix_hyperlink,
-                                  kind: InfoBarUI.UIKind.HyperLink,
-                                  action: new Action(OpenInstallHyperlink)));
+                // If we got true from the experimentation service, then we're in the treatment group, and the experiment is enabled.
+                // We determine if the infobar has been displayed in the past 24 hours. If it hasn't been displayed, then we do so now.
+                var lastDayInfoBarShown = DateTime.FromBinary(_workspace.Options.GetOption(AnalyzerABTestOptions.LastDayInfoBarShown));
+                var utcNow = DateTime.UtcNow;
+                var timeSinceLastShown = utcNow - lastDayInfoBarShown;
+
+                if (timeSinceLastShown.TotalDays >= 1)
+                {
+                    _workspace.Options = _workspace.Options.WithChangedOption(AnalyzerABTestOptions.LastDayInfoBarShown, utcNow.ToBinary());
+
+                    var infoBarService = _workspace.Services.GetRequiredService<IInfoBarService>();
+                    infoBarService.ShowInfoBarInGlobalView(
+                        ServicesVSResources.Analyzer_vsix_try_description,
+                        // Install link
+                        new InfoBarUI(title: ServicesVSResources.Analyzer_vsix_hyperlink,
+                                      kind: InfoBarUI.UIKind.HyperLink,
+                                      action: OpenInstallHyperlink),
+                        // Don't show the InfoBar again link
+                        new InfoBarUI(title: ServicesVSResources.Analyzer_vsix_do_not_show_again,
+                                      kind: InfoBarUI.UIKind.Button,
+                                      action: DoNotShowAgain),
+                        // This element isn't shown, it defines a callback that will be run on InfoBar close
+                        new InfoBarUI(title: string.Empty,
+                                      kind: InfoBarUI.UIKind.Close,
+                                      action: ReleaseChecks));
+                }
+            }
+            else
+            {
+                lock(_scheduleLock)
+                {
+                    _checksRunning = false;
+                }
+            }
+        }
+
+        private void ReleaseChecks()
+        {
+            lock (_scheduleLock)
+            {
+                _checksRunning = false;
             }
         }
 
@@ -41,5 +165,37 @@ private void OpenInstallHyperlink()
         {
             System.Diagnostics.Process.Start(AnalyzerVsixHyperlink);
         }
+
+        private void DoNotShowAgain()
+        {
+            _workspace.Options = _workspace.Options.WithChangedOption(AnalyzerABTestOptions.NeverShowAgain, true);
+        }
+    }
+
+    internal static class AnalyzerABTestOptions
+    {
+        private const string LocalRegistryPath = @"Roslyn\Internal\Analyzers\AB\Vsix\";
+
+        [ExportOption]
+        public static readonly Option<long> LastDayUsedSuggestionAction = new Option<long>(nameof(AnalyzerABTestOptions), nameof(LastDayUsedSuggestionAction),
+            defaultValue: DateTime.MinValue.ToBinary(),
+            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(LastDayUsedSuggestionAction)));
+
+        [ExportOption]
+        public static readonly Option<uint> UsedSuggestedActionCount = new Option<uint>(nameof(AnalyzerABTestOptions), nameof(UsedSuggestedActionCount),
+            defaultValue: 0, storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(UsedSuggestedActionCount)));
+
+        [ExportOption]
+        public static readonly Option<bool> NeverShowAgain = new Option<bool>(nameof(AnalyzerABTestOptions), nameof(NeverShowAgain),
+            defaultValue: false, storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(NeverShowAgain)));
+
+        [ExportOption]
+        public static readonly Option<bool> HasMetCandidacyRequirements = new Option<bool>(nameof(AnalyzerABTestOptions), nameof(HasMetCandidacyRequirements),
+            defaultValue: false, storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(HasMetCandidacyRequirements)));
+
+        [ExportOption]
+        public static readonly Option<long> LastDayInfoBarShown = new Option<long>(nameof(AnalyzerABTestOptions), nameof(LastDayInfoBarShown),
+            defaultValue: DateTime.MinValue.ToBinary(),
+            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(LastDayInfoBarShown)));
     }
 }
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs b/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
index 09fb93e50562c..a6d1c5b6b7854 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
@@ -226,6 +226,15 @@ internal static string Analyzer_reference_to_0_in_project_1 {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Do not show again.
+        /// </summary>
+        internal static string Analyzer_vsix_do_not_show_again {
+            get {
+                return ResourceManager.GetString("Analyzer_vsix_do_not_show_again", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Install.
         /// </summary>
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index b1042e7f920e0..e6f90462b3d35 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -918,4 +918,7 @@ Additional information: {1}</value>
   <data name="Analyzer_vsix_try_description" xml:space="preserve">
     <value>Try the new analyzer extension!</value>
   </data>
+  <data name="Analyzer_vsix_do_not_show_again" xml:space="preserve">
+    <value>Do not show again</value>
+  </data>
 </root>
\ No newline at end of file

From 2458ada36410a3408bbca826a74ab0b1c6750f18 Mon Sep 17 00:00:00 2001
From: vsadov <vsadov@microsoft.com>
Date: Thu, 11 May 2017 11:23:10 -0700
Subject: [PATCH 128/284] Regression test for #19434 which appear to be fixed.

Closes:#19434
---
 .../Test/Emit/CodeGen/CodeGenTupleTest.cs     | 73 +++++++++++++++++++
 1 file changed, 73 insertions(+)

diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs
index 4448de074facf..c3b626178cac4 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs
@@ -22872,5 +22872,78 @@ void M<T>()
                 Diagnostic(ErrorCode.ERR_TypelessTupleInAs, "(0, null) as (int, T)?").WithLocation(6, 17)
                 );
         }
+
+        [Fact]
+        [WorkItem(19434, "https://github.com/dotnet/roslyn/issues/19434")]
+        public void ExplicitTupleLiteralConversionWithNullable01()
+        {
+            var source = @"
+class C
+{
+    static void Main()
+    {
+        int x = 1;
+        var y = ((byte, byte)?)(x, x);
+        System.Console.WriteLine(y.Value);
+    }
+}
+";
+
+            var comp = CompileAndVerify(source,
+                additionalRefs: s_valueTupleRefs, options: TestOptions.DebugExe, expectedOutput:
+@"(1, 1)");
+
+            comp.VerifyIL("C.Main()", @"
+{
+  // Code size       38 (0x26)
+  .maxstack  3
+  .locals init (int V_0, //x
+                (byte, byte)? V_1) //y
+  IL_0000:  nop
+  IL_0001:  ldc.i4.1
+  IL_0002:  stloc.0
+  IL_0003:  ldloca.s   V_1
+  IL_0005:  ldloc.0
+  IL_0006:  conv.u1
+  IL_0007:  ldloc.0
+  IL_0008:  conv.u1
+  IL_0009:  newobj     ""System.ValueTuple<byte, byte>..ctor(byte, byte)""
+  IL_000e:  call       ""(byte, byte)?..ctor((byte, byte))""
+  IL_0013:  ldloca.s   V_1
+  IL_0015:  call       ""(byte, byte) (byte, byte)?.Value.get""
+  IL_001a:  box        ""System.ValueTuple<byte, byte>""
+  IL_001f:  call       ""void System.Console.WriteLine(object)""
+  IL_0024:  nop
+  IL_0025:  ret
+}
+");
+
+            comp = CompileAndVerify(source,
+    additionalRefs: s_valueTupleRefs, options: TestOptions.ReleaseExe, expectedOutput:
+@"(1, 1)");
+
+            comp.VerifyIL("C.Main()", @"
+{
+  // Code size       36 (0x24)
+  .maxstack  3
+  .locals init (int V_0, //x
+                (byte, byte)? V_1) //y
+  IL_0000:  ldc.i4.1
+  IL_0001:  stloc.0
+  IL_0002:  ldloca.s   V_1
+  IL_0004:  ldloc.0
+  IL_0005:  conv.u1
+  IL_0006:  ldloc.0
+  IL_0007:  conv.u1
+  IL_0008:  newobj     ""System.ValueTuple<byte, byte>..ctor(byte, byte)""
+  IL_000d:  call       ""(byte, byte)?..ctor((byte, byte))""
+  IL_0012:  ldloca.s   V_1
+  IL_0014:  call       ""(byte, byte) (byte, byte)?.Value.get""
+  IL_0019:  box        ""System.ValueTuple<byte, byte>""
+  IL_001e:  call       ""void System.Console.WriteLine(object)""
+  IL_0023:  ret
+}
+");
+        }
     }
 }
\ No newline at end of file

From fdc02b9b030f4dfd72e56c640488d912e16a00eb Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Thu, 11 May 2017 12:46:08 -0700
Subject: [PATCH 129/284] Add simplification tests.

---
 .../Test2/EditorServicesTest2.vbproj          |   1 +
 .../BlockSimplificationTests.vb               | 413 ++++++++++++++++++
 .../ParenthesisSimplificationTests.vb         |   1 -
 3 files changed, 414 insertions(+), 1 deletion(-)
 create mode 100644 src/EditorFeatures/Test2/Simplification/BlockSimplificationTests.vb

diff --git a/src/EditorFeatures/Test2/EditorServicesTest2.vbproj b/src/EditorFeatures/Test2/EditorServicesTest2.vbproj
index 53a950f293939..fbbb505f5d119 100644
--- a/src/EditorFeatures/Test2/EditorServicesTest2.vbproj
+++ b/src/EditorFeatures/Test2/EditorServicesTest2.vbproj
@@ -249,6 +249,7 @@
     <Compile Include="IntelliSense\CompletionRulesTests.vb" />
     <Compile Include="LanguageServices\SyntaxFactsServiceTests.vb" />
     <Compile Include="NamingStyles\NamingStylesTests.vb" />
+    <Compile Include="Simplification\BlockSimplificationTests.vb" />
     <Compile Include="Simplification\SimplifierAPITests.vb" />
     <Compile Include="CodeFixes\CodeFixServiceTests.vb" />
     <Compile Include="Compilation\CompilationTests.vb" />
diff --git a/src/EditorFeatures/Test2/Simplification/BlockSimplificationTests.vb b/src/EditorFeatures/Test2/Simplification/BlockSimplificationTests.vb
new file mode 100644
index 0000000000000..c133fc37cd0dd
--- /dev/null
+++ b/src/EditorFeatures/Test2/Simplification/BlockSimplificationTests.vb
@@ -0,0 +1,413 @@
+' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+Imports System.Threading.Tasks
+Imports Microsoft.CodeAnalysis.CodeStyle
+Imports Microsoft.CodeAnalysis.CSharp.CodeStyle
+Imports Microsoft.CodeAnalysis.Options
+
+Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Simplification
+    Public Class SimplificationTests
+        Inherits AbstractSimplificationTests
+
+        Private Shared ReadOnly DoNotPreferBraces As Dictionary(Of OptionKey, Object) = New Dictionary(Of OptionKey, Object) From {{New OptionKey(CSharpCodeStyleOptions.PreferBraces), CodeStyleOptions.FalseWithNoneEnforcement}}
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Simplification)>
+        Public Async Function TestCSharp_DoNotSimplifyIfBlock() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+class Program
+{
+    void M()
+    {
+        if (true)
+        {|Simplify:{
+            return;
+        }|}
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+
+            Dim expected =
+<code>
+class Program
+{
+    void M()
+    {
+        if (true)
+        {
+            return;
+        }
+    }
+}
+</code>
+
+            Await TestAsync(input, expected)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Simplification)>
+        Public Async Function TestCSharp_DoNotSimplifyMethodBlock() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+class Program
+{
+    void M()
+    {|Simplify:{
+        return;
+    }|}
+}
+        </Document>
+    </Project>
+</Workspace>
+
+            Dim expected =
+<code>
+class Program
+{
+    void M()
+    {
+        return;
+    }
+}
+</code>
+
+            Await TestAsync(input, expected, DoNotPreferBraces)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Simplification)>
+        Public Async Function TestCSharp_DoNotSimplifyTryBlock() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+class Program
+{
+    void M()
+    {
+        try
+        {|Simplify:{
+            return;
+        }|}
+        finally
+        {
+        }
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+
+            Dim expected =
+<code>
+class Program
+{
+    void M()
+    {
+        try
+        {
+            return;
+        }
+        finally
+        {
+        }
+    }
+}
+</code>
+
+            Await TestAsync(input, expected, DoNotPreferBraces)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Simplification)>
+        Public Async Function TestCSharp_SimplifyIfBlock() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+class Program
+{
+    void M()
+    {
+        if (true)
+        {|Simplify:{
+            return;
+        }|}
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+
+            Dim expected =
+<code>
+class Program
+{
+    void M()
+    {
+        if (true)
+            return;
+    }
+}
+</code>
+
+            Await TestAsync(input, expected, DoNotPreferBraces)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Simplification)>
+        Public Async Function TestCSharp_SimplifyElseBlock() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+class Program
+{
+    void M()
+    {
+        if (true)
+        {
+        }
+        else
+        {|Simplify:{
+            return;
+        }|}
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+
+            Dim expected =
+<code>
+class Program
+{
+    void M()
+    {
+        if (true)
+        {
+        }
+        else
+            return;
+    }
+}
+</code>
+
+            Await TestAsync(input, expected, DoNotPreferBraces)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Simplification)>
+        Public Async Function TestCSharp_SimplifyWhileBlock() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+class Program
+{
+    void M()
+    {
+        while (true)
+        {|Simplify:{
+            return;
+        }|}
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+
+            Dim expected =
+<code>
+class Program
+{
+    void M()
+    {
+        while (true)
+            return;
+    }
+}
+</code>
+
+            Await TestAsync(input, expected, DoNotPreferBraces)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Simplification)>
+        Public Async Function TestCSharp_SimplifyDoBlock() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+class Program
+{
+    void M()
+    {
+        do
+        {|Simplify:{
+            return;
+        }|}
+        while (true);
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+
+            Dim expected =
+<code>
+class Program
+{
+    void M()
+    {
+        do
+            return;
+        while (true);
+    }
+}
+</code>
+
+            Await TestAsync(input, expected, DoNotPreferBraces)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Simplification)>
+        Public Async Function TestCSharp_SimplifyUsingBlock() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+class Program
+{
+    void M()
+    {
+        using (x)
+        {|Simplify:{
+            return;
+        }|}
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+
+            Dim expected =
+<code>
+class Program
+{
+    void M()
+    {
+        using (x)
+            return;
+    }
+}
+</code>
+
+            Await TestAsync(input, expected, DoNotPreferBraces)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Simplification)>
+        Public Async Function TestCSharp_SimplifyLockBlock() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+class Program
+{
+    void M()
+    {
+        lock (x)
+        {|Simplify:{
+            return;
+        }|}
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+
+            Dim expected =
+<code>
+class Program
+{
+    void M()
+    {
+        lock (x)
+            return;
+    }
+}
+</code>
+
+            Await TestAsync(input, expected, DoNotPreferBraces)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Simplification)>
+        Public Async Function TestCSharp_SimplifyForBlock() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+class Program
+{
+    void M()
+    {
+        for (;;)
+        {|Simplify:{
+            return;
+        }|}
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+
+            Dim expected =
+<code>
+class Program
+{
+    void M()
+    {
+        for (;;)
+            return;
+    }
+}
+</code>
+
+            Await TestAsync(input, expected, DoNotPreferBraces)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Simplification)>
+        Public Async Function TestCSharp_SimplifyForeachBlock() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+class Program
+{
+    void M()
+    {
+        foreach (var x in y)
+        {|Simplify:{
+            return;
+        }|}
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+
+            Dim expected =
+<code>
+class Program
+{
+    void M()
+    {
+        foreach (var x in y)
+            return;
+    }
+}
+</code>
+
+            Await TestAsync(input, expected, DoNotPreferBraces)
+        End Function
+    End Class
+End Namespace
\ No newline at end of file
diff --git a/src/EditorFeatures/Test2/Simplification/ParenthesisSimplificationTests.vb b/src/EditorFeatures/Test2/Simplification/ParenthesisSimplificationTests.vb
index bf9d327bc3a0a..43a1fc84e8a5c 100644
--- a/src/EditorFeatures/Test2/Simplification/ParenthesisSimplificationTests.vb
+++ b/src/EditorFeatures/Test2/Simplification/ParenthesisSimplificationTests.vb
@@ -663,7 +663,6 @@ class Foo{
 </code>
 
             Await TestAsync(input, expected)
-
         End Function
 
         <WorkItem(619292, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/619292")>

From c757297b2884a9d2c15124a3053b58645f0daca4 Mon Sep 17 00:00:00 2001
From: Tom Meschter <tom.meschter@microsoft.com>
Date: Thu, 11 May 2017 13:02:14 -0700
Subject: [PATCH 130/284] Extract out the ExtractAnalyzerFilePath method

Move the method to its own type (`CpsUtilities`) and add some basic unit tests.
---
 .../DiagnosticItem/CpsDiagnosticItemSource.cs | 43 ++-----------
 .../DiagnosticItem/CpsUtilities.cs            | 60 +++++++++++++++++++
 .../SolutionExplorerShim.csproj               |  1 +
 .../Core/Test/ServicesVisualStudioTest.vbproj |  1 +
 .../SolutionExplorer/CpsUtilitiesTests.vb     | 38 ++++++++++++
 5 files changed, 104 insertions(+), 39 deletions(-)
 create mode 100644 src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsUtilities.cs
 create mode 100644 src/VisualStudio/Core/Test/SolutionExplorer/CpsUtilitiesTests.vb

diff --git a/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsDiagnosticItemSource.cs b/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsDiagnosticItemSource.cs
index af77b64267226..b8f333704380c 100644
--- a/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsDiagnosticItemSource.cs
+++ b/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsDiagnosticItemSource.cs
@@ -95,49 +95,14 @@ private AnalyzerReference TryGetAnalyzerReference(Solution solution)
             }
 
             var canonicalName = _item.CanonicalName;
-            var analyzerFilePath = ExtractAnalyzerFilePath(canonicalName);
+            var analyzerFilePath = CpsUtilities.ExtractAnalyzerFilePath(_projectDirectoryPath, canonicalName);
 
-            return project.AnalyzerReferences.FirstOrDefault(r => r.FullPath.Equals(analyzerFilePath, StringComparison.OrdinalIgnoreCase));
-        }
-
-        /// <summary>
-        /// Given the canonical name of a node representing an analyzer assembly in the
-        /// CPS-based project system extracts out the full path to the assembly.
-        /// </summary>
-        /// <remarks>
-        /// The canonical name takes the following form:
-        /// 
-        ///   [{path to project directory}\]{target framework}\analyzerdependency\{path to assembly}
-        ///   
-        /// e.g.:
-        /// 
-        ///   C:\projects\solutions\MyProj\netstandard2.0\analyzerdependency\C:\users\me\.packages\somePackage\lib\someAnalyzer.dll
-        ///   
-        /// This method exists solely to extract out the "path to assembly" part, i.e.
-        /// "C:\users\me\.packages\somePackage\lib\someAnalyzer.dll". We don't need the
-        /// other parts.
-        /// 
-        /// Note that the path to the project directory is optional. It's not clear if
-        /// this is intentional or a bug in the project system, but either way it
-        /// doesn't really matter.
-        /// </remarks>
-        private string ExtractAnalyzerFilePath(string canonicalName)
-        {
-            // The canonical name may or may not start with the path to the project's directory.
-            if (canonicalName.StartsWith(_projectDirectoryPath, StringComparison.OrdinalIgnoreCase))
+            if (string.IsNullOrEmpty(analyzerFilePath))
             {
-                // Extract the rest of the string, taking into account the "\" separating the directory
-                // path from the rest of the canonical name
-                canonicalName = canonicalName.Substring(_projectDirectoryPath.Length + 1);
+                return null;
             }
 
-            // Find the slash after the target framework
-            var backslashIndex = canonicalName.IndexOf('\\');
-            // Find the slash after "analyzerdependency"
-            backslashIndex = canonicalName.IndexOf('\\', backslashIndex + 1);
-
-            // The rest of the string is the path.
-            return canonicalName.Substring(backslashIndex + 1);
+            return project.AnalyzerReferences.FirstOrDefault(r => r.FullPath.Equals(analyzerFilePath, StringComparison.OrdinalIgnoreCase));
         }
     }
 }
\ No newline at end of file
diff --git a/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsUtilities.cs b/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsUtilities.cs
new file mode 100644
index 0000000000000..810e14cc93b73
--- /dev/null
+++ b/src/VisualStudio/Core/SolutionExplorerShim/DiagnosticItem/CpsUtilities.cs
@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.SolutionExplorer
+{
+    internal static class CpsUtilities
+    {
+        /// <summary>
+        /// Given the canonical name of a node representing an analyzer assembly in the
+        /// CPS-based project system extracts out the full path to the assembly.
+        /// </summary>
+        /// <param name="projectDirectoryPath">The full path to the project directory</param>
+        /// <param name="analyzerNodeCanonicalName">The canonical name of the analyzer node in the hierarchy</param>
+        /// <returns>The full path to the analyzer assembly on disk, or null if <paramref name="analyzerNodeCanonicalName"/>
+        /// cannot be parsed.</returns>
+        /// <remarks>
+        /// The canonical name takes the following form:
+        /// 
+        ///   [{path to project directory}\]{target framework}\analyzerdependency\{path to assembly}
+        ///   
+        /// e.g.:
+        /// 
+        ///   C:\projects\solutions\MyProj\netstandard2.0\analyzerdependency\C:\users\me\.packages\somePackage\lib\someAnalyzer.dll
+        ///   
+        /// This method exists solely to extract out the "path to assembly" part, i.e.
+        /// "C:\users\me\.packages\somePackage\lib\someAnalyzer.dll". We don't need the
+        /// other parts.
+        /// 
+        /// Note that the path to the project directory is optional.
+        /// </remarks>
+        public static string ExtractAnalyzerFilePath(string projectDirectoryPath, string analyzerNodeCanonicalName)
+        {
+            // The canonical name may or may not start with the path to the project's directory.
+            if (analyzerNodeCanonicalName.StartsWith(projectDirectoryPath, StringComparison.OrdinalIgnoreCase))
+            {
+                // Extract the rest of the string, taking into account the "\" separating the directory
+                // path from the rest of the canonical name
+                analyzerNodeCanonicalName = analyzerNodeCanonicalName.Substring(projectDirectoryPath.Length + 1);
+            }
+
+            // Find the slash after the target framework
+            var backslashIndex = analyzerNodeCanonicalName.IndexOf('\\');
+            if (backslashIndex < 0)
+            {
+                return null;
+            }
+
+            // Find the slash after "analyzerdependency"
+            backslashIndex = analyzerNodeCanonicalName.IndexOf('\\', backslashIndex + 1);
+            if (backslashIndex < 0)
+            {
+                return null;
+            }
+
+            // The rest of the string is the path.
+            return analyzerNodeCanonicalName.Substring(backslashIndex + 1);
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/SolutionExplorerShim/SolutionExplorerShim.csproj b/src/VisualStudio/Core/SolutionExplorerShim/SolutionExplorerShim.csproj
index 6956b8ac50729..e1dba79391e6d 100644
--- a/src/VisualStudio/Core/SolutionExplorerShim/SolutionExplorerShim.csproj
+++ b/src/VisualStudio/Core/SolutionExplorerShim/SolutionExplorerShim.csproj
@@ -99,6 +99,7 @@
     <Compile Include="DiagnosticItem\CpsDiagnosticItemProvider.cs" />
     <Compile Include="DiagnosticItem\CpsDiagnosticItemSource.cs" />
     <Compile Include="DiagnosticItem\BaseDiagnosticItem.BrowseObject.cs" />
+    <Compile Include="DiagnosticItem\CpsUtilities.cs" />
     <Compile Include="DiagnosticItem\LegacyDiagnosticItemProvider.cs" />
     <Compile Include="AnalyzerReferenceManager.cs" />
     <Compile Include="ContextMenuController.cs" />
diff --git a/src/VisualStudio/Core/Test/ServicesVisualStudioTest.vbproj b/src/VisualStudio/Core/Test/ServicesVisualStudioTest.vbproj
index 67d1e6fcf7af6..dfffed21f54b9 100644
--- a/src/VisualStudio/Core/Test/ServicesVisualStudioTest.vbproj
+++ b/src/VisualStudio/Core/Test/ServicesVisualStudioTest.vbproj
@@ -388,6 +388,7 @@
     <Compile Include="Help\HelpTests.vb" />
     <Compile Include="LanguageBlockTests.vb" />
     <Compile Include="SolutionExplorer\CpsDiagnosticItemTests.vb" />
+    <Compile Include="SolutionExplorer\CpsUtilitiesTests.vb" />
     <Compile Include="SymbolSearch\SymbolSearchUpdateEngineTests.vb" />
     <Compile Include="Telemetry\VSTelemetryLoggerTest.vb" />
     <Compile Include="Utilities\VsNavInfoHelpers.vb" />
diff --git a/src/VisualStudio/Core/Test/SolutionExplorer/CpsUtilitiesTests.vb b/src/VisualStudio/Core/Test/SolutionExplorer/CpsUtilitiesTests.vb
new file mode 100644
index 0000000000000..842e2a9b1ce0b
--- /dev/null
+++ b/src/VisualStudio/Core/Test/SolutionExplorer/CpsUtilitiesTests.vb
@@ -0,0 +1,38 @@
+' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+Imports Microsoft.VisualStudio.LanguageServices.Implementation.SolutionExplorer
+Imports Roslyn.Test.Utilities
+
+Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.SolutionExplorer
+
+    Public Class CpsUtilitiesTests
+        <Fact, Trait(Traits.Feature, Traits.Features.Diagnostics)>
+        Public Sub ExtractAnalyzerFilePath_WithProjectPath()
+            Dim projectDirectoryFullPath = "C:\users\me\Solution\Project"
+            Dim analyzerCanonicalName = "C:\users\me\Solution\Project\netstandard2.0\analyzerdependency\C:\users\me\.nuget\package\analyzer\MyAnalyzer.dll"
+
+            Dim analyzerFileFullPath = CpsUtilities.ExtractAnalyzerFilePath(projectDirectoryFullPath, analyzerCanonicalName)
+            Assert.Equal(expected:="C:\users\me\.nuget\package\analyzer\MyAnalyzer.dll", actual:=analyzerFileFullPath)
+        End Sub
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Diagnostics)>
+        Public Sub ExtractAnalyzerFilePath_WithoutProjectPath()
+            Dim projectDirectoryFullPath = "C:\users\me\Solution\Project"
+            Dim analyzerCanonicalName = "netstandard2.0\analyzerdependency\C:\users\me\.nuget\package\analyzer\MyAnalyzer.dll"
+
+            Dim analyzerFileFullPath = CpsUtilities.ExtractAnalyzerFilePath(projectDirectoryFullPath, analyzerCanonicalName)
+            Assert.Equal(expected:="C:\users\me\.nuget\package\analyzer\MyAnalyzer.dll", actual:=analyzerFileFullPath)
+        End Sub
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Diagnostics)>
+        Public Sub ExtractAnalyzerFilePath_MalformedCanonicalName()
+            Dim projectDirectoryFullPath = "C:\users\me\Solution\Project"
+            Dim analyzerCanonicalName = "alpha beta gamma"
+
+            Dim analyzerFileFullPath = CpsUtilities.ExtractAnalyzerFilePath(projectDirectoryFullPath, analyzerCanonicalName)
+            Assert.Null(analyzerFileFullPath)
+        End Sub
+    End Class
+
+End Namespace
+

From ca449a6b323d0bc4aa3ed699521419a45da04a92 Mon Sep 17 00:00:00 2001
From: Ivan Basov <basov@hotmail.com>
Date: Thu, 11 May 2017 13:22:32 -0700
Subject: [PATCH 131/284] Disabling flakey tests covered by #19441 (#19442)

tests only. no ask mode approval is required. thanks!
---
 .../IntegrationTests/CSharp/CSharpSendToInteractive.cs        | 2 +-
 .../IntegrationTests/VisualBasic/BasicEditAndContinue.cs      | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpSendToInteractive.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpSendToInteractive.cs
index 4c3c3bb94c53c..a1864f5fc5b32 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpSendToInteractive.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpSendToInteractive.cs
@@ -214,7 +214,7 @@ public void AddAssemblyReferenceAndTypesToInteractive()
             VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.SolutionCrawler);
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void ResetInteractiveFromProjectAndVerify()
         {
             var assembly = new ProjectUtils.AssemblyReference("System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
index 7643daa7d20bd..9d486ff80858c 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
@@ -54,7 +54,7 @@ End Module
             VisualStudio.Debugger.CheckExpression("names(1)", "String", "\"bar\"");
         }
 
-        [Fact]
+        [Fact (Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void AddTryCatchAroundActiveStatement()
         {
             VisualStudio.Editor.SetText(@"
@@ -294,7 +294,7 @@ End Module
             VisualStudio.LocalsWindow.Verify.CheckEntry("lLng", "Long", "444");
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void WatchWindowUpdatesCorrectlyDuringEnC()
         {
             VisualStudio.Editor.SetText(@"

From 0d01ae98b23a62ebc93785e3f8610d6d637631df Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Thu, 11 May 2017 13:26:07 -0700
Subject: [PATCH 132/284] Be resilient to null-paths/names for
 Documents/Projects in SqlitePersistence layer.

---
 .../SQLite/SQLitePersistentStorage_BulkPopulateIds.cs        | 5 +++++
 .../Workspace/SQLite/SQLitePersistentStorage_StringIds.cs    | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_BulkPopulateIds.cs b/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_BulkPopulateIds.cs
index 1aa508b8e7da2..d69b38da02ee1 100644
--- a/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_BulkPopulateIds.cs
+++ b/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_BulkPopulateIds.cs
@@ -202,6 +202,11 @@ string GetDocumentIdString(Document document)
 
             void AddIfUnknownId(string value, HashSet<string> stringsToAdd)
             {
+                if (value == null)
+                {
+                    return;
+                }
+
                 if (!_stringToIdMap.TryGetValue(value, out var id))
                 {
                     stringsToAdd.Add(value);
diff --git a/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_StringIds.cs b/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_StringIds.cs
index d31044441a44b..b2a51555c3f82 100644
--- a/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_StringIds.cs
+++ b/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_StringIds.cs
@@ -34,6 +34,11 @@ private void FetchStringTable(SqlConnection connection)
 
         private int? TryGetStringId(SqlConnection connection, string value)
         {
+            if (value == null)
+            {
+                return null;
+            }
+
             // First see if we've cached the ID for this value locally.  If so, just return
             // what we already have.
             if (_stringToIdMap.TryGetValue(value, out int existingId))

From f125368c2951def311bd0796189a88a1bd3857ca Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Thu, 11 May 2017 13:45:14 -0700
Subject: [PATCH 133/284] Add tests.

---
 .../AbstractPersistentStorageTests.cs         | 22 ++++++++++---------
 .../SQLitePersistentStorageTests.cs           | 22 +++++++++++++++++++
 2 files changed, 34 insertions(+), 10 deletions(-)

diff --git a/src/VisualStudio/CSharp/Test/PersistentStorage/AbstractPersistentStorageTests.cs b/src/VisualStudio/CSharp/Test/PersistentStorage/AbstractPersistentStorageTests.cs
index 9920ee9e0909c..8a50e33ccc1f2 100644
--- a/src/VisualStudio/CSharp/Test/PersistentStorage/AbstractPersistentStorageTests.cs
+++ b/src/VisualStudio/CSharp/Test/PersistentStorage/AbstractPersistentStorageTests.cs
@@ -368,11 +368,11 @@ private void DoSimultaneousReads(Func<Task<string>> read, string expectedValue)
             Assert.Equal(new List<Exception>(), exceptions);
         }
 
-        private Solution CreateOrOpenSolution()
+        protected Solution CreateOrOpenSolution(bool nullPaths = false)
         {
-            string solutionFile = Path.Combine(_persistentFolder, "Solution1.sln");
-            bool newSolution;
-            if (newSolution = !File.Exists(solutionFile))
+            var solutionFile = Path.Combine(_persistentFolder, "Solution1.sln");
+            var newSolution = !File.Exists(solutionFile);
+            if (newSolution)
             {
                 File.WriteAllText(solutionFile, "");
             }
@@ -386,20 +386,22 @@ private Solution CreateOrOpenSolution()
 
             if (newSolution)
             {
-                string projectFile = Path.Combine(Path.GetDirectoryName(solutionFile), "Project1.csproj");
+                var projectFile = Path.Combine(Path.GetDirectoryName(solutionFile), "Project1.csproj");
                 File.WriteAllText(projectFile, "");
-                solution = solution.AddProject(ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(), "Project1", "Project1", LanguageNames.CSharp, projectFile));
+                solution = solution.AddProject(ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(), "Project1", "Project1", LanguageNames.CSharp, 
+                    filePath: nullPaths ? null : projectFile));
                 var project = solution.Projects.Single();
 
-                string documentFile = Path.Combine(Path.GetDirectoryName(projectFile), "Document1.cs");
+                var documentFile = Path.Combine(Path.GetDirectoryName(projectFile), "Document1.cs");
                 File.WriteAllText(documentFile, "");
-                solution = solution.AddDocument(DocumentInfo.Create(DocumentId.CreateNewId(project.Id), "Document1", filePath: documentFile));
+                solution = solution.AddDocument(DocumentInfo.Create(DocumentId.CreateNewId(project.Id), "Document1", 
+                    filePath: nullPaths ? null : documentFile));
             }
 
             return solution;
         }
 
-        private IPersistentStorage GetStorage(Solution solution)
+        protected IPersistentStorage GetStorage(Solution solution)
         {
             var storage = GetStorageService().GetStorage(solution);
 
@@ -409,7 +411,7 @@ private IPersistentStorage GetStorage(Solution solution)
 
         protected abstract IPersistentStorageService GetStorageService();
 
-        private Stream EncodeString(string text)
+        protected Stream EncodeString(string text)
         {
             var bytes = _encoding.GetBytes(text);
             var stream = new MemoryStream(bytes);
diff --git a/src/VisualStudio/CSharp/Test/PersistentStorage/SQLitePersistentStorageTests.cs b/src/VisualStudio/CSharp/Test/PersistentStorage/SQLitePersistentStorageTests.cs
index 76fef5abd275b..c897c63842e2c 100644
--- a/src/VisualStudio/CSharp/Test/PersistentStorage/SQLitePersistentStorageTests.cs
+++ b/src/VisualStudio/CSharp/Test/PersistentStorage/SQLitePersistentStorageTests.cs
@@ -1,7 +1,10 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.SQLite;
+using Xunit;
 
 namespace Microsoft.CodeAnalysis.UnitTests.WorkspaceServices
 {
@@ -14,5 +17,24 @@ public class SQLitePersistentStorageTests : AbstractPersistentStorageTests
     {
         protected override IPersistentStorageService GetStorageService()
             => new SQLitePersistentStorageService(_persistentEnabledOptionService, testing: true);
+
+        [Fact]
+        public async Task TestNullFilePaths()
+        {
+            var solution = CreateOrOpenSolution(nullPaths: true);
+
+            var streamName = "stream";
+
+            using (var storage = GetStorage(solution))
+            {
+                var project = solution.Projects.First();
+                var document = project.Documents.First();
+                Assert.False(await storage.WriteStreamAsync(project, streamName, EncodeString("")));
+                Assert.False(await storage.WriteStreamAsync(document, streamName, EncodeString("")));
+
+                Assert.Null(await storage.ReadStreamAsync(project, streamName));
+                Assert.Null(await storage.ReadStreamAsync(document, streamName));
+            }
+        }
     }
 }
\ No newline at end of file

From f1979f7a352c0a59afa900aef82b2af0eaed6eab Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Thu, 11 May 2017 13:52:08 -0700
Subject: [PATCH 134/284] Add comments.

---
 .../SQLite/SQLitePersistentStorage_BulkPopulateIds.cs          | 3 +++
 .../Workspace/SQLite/SQLitePersistentStorage_StringIds.cs      | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_BulkPopulateIds.cs b/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_BulkPopulateIds.cs
index d69b38da02ee1..8d53bb248e0f0 100644
--- a/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_BulkPopulateIds.cs
+++ b/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_BulkPopulateIds.cs
@@ -202,6 +202,9 @@ string GetDocumentIdString(Document document)
 
             void AddIfUnknownId(string value, HashSet<string> stringsToAdd)
             {
+                // Null strings are not supported at all.  Just ignore these. Any read/writes 
+                // to null values will fail and will return 'false/null' to indicate failure
+                // (which is part of the documented contract of the persistence layer API).
                 if (value == null)
                 {
                     return;
diff --git a/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_StringIds.cs b/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_StringIds.cs
index b2a51555c3f82..ef86b5fb3b51e 100644
--- a/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_StringIds.cs
+++ b/src/Workspaces/Core/Desktop/Workspace/SQLite/SQLitePersistentStorage_StringIds.cs
@@ -34,6 +34,9 @@ private void FetchStringTable(SqlConnection connection)
 
         private int? TryGetStringId(SqlConnection connection, string value)
         {
+            // Null strings are not supported at all.  Just ignore these. Any read/writes 
+            // to null values will fail and will return 'false/null' to indicate failure
+            // (which is part of the documented contract of the persistence layer API).
             if (value == null)
             {
                 return null;

From 776045a400a7c5120e69a8763f14e9f4ac9f36b3 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Thu, 11 May 2017 13:56:07 -0700
Subject: [PATCH 135/284] Added in check for VSIX installation. Moved all
 checks to background thread.

---
 .../VisualStudioExperimentationService.cs     |  4 +-
 .../AnalyzerVsixSuggestedActionCallback.cs    | 83 +++++++++++++------
 2 files changed, 61 insertions(+), 26 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Experimentation/VisualStudioExperimentationService.cs b/src/VisualStudio/Core/Def/Experimentation/VisualStudioExperimentationService.cs
index 85416bfa9cd47..96503af8825b6 100644
--- a/src/VisualStudio/Core/Def/Experimentation/VisualStudioExperimentationService.cs
+++ b/src/VisualStudio/Core/Def/Experimentation/VisualStudioExperimentationService.cs
@@ -2,6 +2,7 @@
 
 using System.Composition;
 using System.Reflection;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Experiments;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.Internal.VisualStudio.Shell.Interop;
@@ -10,7 +11,7 @@
 namespace Microsoft.VisualStudio.LanguageServices.Experimentation
 {
     [ExportWorkspaceService(typeof(IExperimentationService), ServiceLayer.Host), Shared]
-    internal class VisualStudioExperimentationService : IExperimentationService
+    internal class VisualStudioExperimentationService : ForegroundThreadAffinitizedObject, IExperimentationService
     {
         private readonly object _experimentationServiceOpt;
         private readonly MethodInfo _isCachedFlightEnabledInfo;
@@ -35,6 +36,7 @@ public VisualStudioExperimentationService(
 
         public bool IsExperimentEnabled(string experimentName)
         {
+            ThisCanBeCalledOnAnyThread();
             if (_isCachedFlightEnabledInfo != null)
             {
                 try
diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
index dbd047418dbe9..a53112822b7ad 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -3,7 +3,6 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.Composition;
-using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Implementation.Suggestions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
@@ -11,6 +10,9 @@
 using Microsoft.CodeAnalysis.Extensions;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Shell.Interop;
+using Task = System.Threading.Tasks.Task;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.Experimentation
 {
@@ -19,31 +21,61 @@ internal class AnalyzerVsixSuggestedActionCallback : ForegroundThreadAffinitized
     {
         private const string AnalyzerEnabledFlight = @"LiveCA/LiveCAcf";
         private const string AnalyzerVsixHyperlink = @"https://aka.ms/livecodeanalysis";
+        private static readonly Guid FxCopAnalyzersPackageGuid = Guid.Parse("{4A41D270-A97F-4639-A352-28732FC410E4}");
 
         private readonly VisualStudioWorkspace _workspace;
         private readonly IForegroundNotificationService _foregroundNotificationService;
         private readonly IAsynchronousOperationListener _operationListener;
+        private readonly SVsServiceProvider _serviceProvider;
 
         private readonly object _scheduleLock = new object();
+        // If we are currently checking to see if the user fits the treatment profile, then we don't want to schedule another check
         private bool _checksRunning = false;
+        // We don't show the user an infobar more than once per VS session
+        private bool _infoBarShown = false;
+        private FxCopInstallStatus _installStatus = FxCopInstallStatus.Unchecked;
+        // Initialized the first time we're on the UI thread
+        private IExperimentationService _experimentationService;
 
         [ImportingConstructor]
         public AnalyzerVsixSuggestedActionCallback(VisualStudioWorkspace workspace,
             IForegroundNotificationService foregroundNotificationService,
-            [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners)
+            [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners,
+            SVsServiceProvider serviceProvider)
         {
             _workspace = workspace;
             _foregroundNotificationService = foregroundNotificationService;
             _operationListener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.ABTest);
+            _serviceProvider = serviceProvider;
         }
 
         public void OnSuggestedActionExecuted(SuggestedAction action)
         {
             AssertIsForeground();
 
+            // Initialize the experimentation service if it hasn't yet been fetched
+            if (_experimentationService == null)
+            {
+                _experimentationService = _workspace.Services.GetRequiredService<IExperimentationService>();
+            }
+
+            // If we haven't yet checked to see if the VSIX is installed, check now
+            if (_installStatus == FxCopInstallStatus.Unchecked)
+            {
+                var vsShell = _serviceProvider.GetService(typeof(SVsShell)) as IVsShell;
+                ErrorHandler.ThrowOnFailure(vsShell.IsPackageInstalled(FxCopAnalyzersPackageGuid, out int installed));
+                _installStatus = installed != 0 ? FxCopInstallStatus.Installed : FxCopInstallStatus.NotInstalled;
+            }
+
+            // Only proceed if the VSIX isn't installed
+            if (_installStatus == FxCopInstallStatus.Installed)
+            {
+                return;
+            }
+
             lock (_scheduleLock)
             {
-                if (!_checksRunning)
+                if (!_checksRunning && !_infoBarShown)
                 {
                     _checksRunning = true;
                     Task.Run((Action)SuggestedActionOccurred);
@@ -61,7 +93,13 @@ private void SuggestedActionOccurred()
             // If the user has previously clicked don't show again, then we bail out immediately
             if (options.GetOption(AnalyzerABTestOptions.NeverShowAgain))
             {
-                // We purposefully do not set _checksRunning back to false. That way, we'll never check again this session
+                // We set _infoBarShown to true here to make sure that we never run these checks again
+                lock(_scheduleLock)
+                {
+                    _checksRunning = false;
+                    _infoBarShown = true;
+                }
+
                 return;
             }
 
@@ -104,18 +142,12 @@ private void SuggestedActionOccurred()
                 return;
             }
 
-            // Queue the show notification bar to the UI thread. This will set _checksRunning back to true after it has shown the infobar
-            _foregroundNotificationService.RegisterNotification((Action)ShowInfoBarIfNecessary,
-                _operationListener.BeginAsyncOperation(nameof(ShowInfoBarIfNecessary)));
+            ShowInfoBarIfNecessary();
         }
 
         private void ShowInfoBarIfNecessary()
         {
-            // We can only get the experimentation service on the UI thread
-            AssertIsForeground();
-
-            var experimentationService = _workspace.Services.GetRequiredService<IExperimentationService>();
-            if (experimentationService.IsExperimentEnabled(AnalyzerEnabledFlight))
+            if (_experimentationService.IsExperimentEnabled(AnalyzerEnabledFlight))
             {
                 // If we got true from the experimentation service, then we're in the treatment group, and the experiment is enabled.
                 // We determine if the infobar has been displayed in the past 24 hours. If it hasn't been displayed, then we do so now.
@@ -137,11 +169,13 @@ private void ShowInfoBarIfNecessary()
                         // Don't show the InfoBar again link
                         new InfoBarUI(title: ServicesVSResources.Analyzer_vsix_do_not_show_again,
                                       kind: InfoBarUI.UIKind.Button,
-                                      action: DoNotShowAgain),
-                        // This element isn't shown, it defines a callback that will be run on InfoBar close
-                        new InfoBarUI(title: string.Empty,
-                                      kind: InfoBarUI.UIKind.Close,
-                                      action: ReleaseChecks));
+                                      action: DoNotShowAgain));
+
+                    lock(_scheduleLock)
+                    {
+                        _checksRunning = false;
+                        _infoBarShown = true;
+                    }
                 }
             }
             else
@@ -153,14 +187,6 @@ private void ShowInfoBarIfNecessary()
             }
         }
 
-        private void ReleaseChecks()
-        {
-            lock (_scheduleLock)
-            {
-                _checksRunning = false;
-            }
-        }
-
         private void OpenInstallHyperlink()
         {
             System.Diagnostics.Process.Start(AnalyzerVsixHyperlink);
@@ -170,6 +196,13 @@ private void DoNotShowAgain()
         {
             _workspace.Options = _workspace.Options.WithChangedOption(AnalyzerABTestOptions.NeverShowAgain, true);
         }
+
+        private enum FxCopInstallStatus
+        {
+            Unchecked,
+            Installed,
+            NotInstalled
+        }
     }
 
     internal static class AnalyzerABTestOptions

From 89ad231429a95b5511dbc052ec4e6aa61e5ed66b Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Thu, 11 May 2017 13:57:31 -0700
Subject: [PATCH 136/284] Refout: Re-enable NoPia, add tests from feature
 review (#19416)

---
 docs/features/refout.md                       |  34 +-
 .../Portable/CSharpResources.Designer.cs      |   9 -
 .../CSharp/Portable/CSharpResources.resx      |   3 -
 .../CommandLine/CSharpCommandLineParser.cs    |   5 -
 .../CSharp/Portable/Errors/ErrorCode.cs       |   2 +-
 .../Test/CommandLine/CommandLineTests.cs      |  10 +-
 .../Test/Emit/Emit/CompilationEmitTests.cs    | 434 +++++++++++++++---
 .../CodeAnalysisResources.Designer.cs         |   9 -
 .../Core/Portable/CodeAnalysisResources.resx  |   3 -
 .../Core/Portable/Compilation/Compilation.cs  |   7 -
 .../VisualBasicCommandLineParser.vb           |   4 -
 .../VisualBasic/Portable/Errors/Errors.vb     |   1 -
 .../Portable/VBResources.Designer.vb          |   9 -
 .../VisualBasic/Portable/VBResources.resx     |   3 -
 .../Test/CommandLine/CommandLineTests.vb      |   6 +-
 .../Test/Emit/Emit/CompilationEmitTests.vb    |  81 ++--
 .../CommonTestBase.CompilationVerifier.cs     |   2 +-
 17 files changed, 443 insertions(+), 179 deletions(-)

diff --git a/docs/features/refout.md b/docs/features/refout.md
index 81253cb00f310..9231dd37ee3f9 100644
--- a/docs/features/refout.md
+++ b/docs/features/refout.md
@@ -1,6 +1,7 @@
 # Reference assemblies
 
 Reference assemblies are metadata-only assemblies with the minimum amount of metadata to preserve the compile-time behavior of consumers (diagnostics may be affected, though).
+The compiler may choose to remove more metadata in later versions, if it is determined to be safe (ie. respects the principle above).
 
 ## Scenarios
 There are 4 scenarios:
@@ -13,17 +14,14 @@ There are 4 scenarios:
 
 ## Definition of ref assemblies
 Metadata-only assembly have their method bodies replaced with a single `throw null` body, but include all members except anonymous types. The reason for using `throw null` bodies (as opposed to no bodies) is so that PEVerify could run and pass (thus validating the completeness of the metadata).
-Ref assemblies further remove metadata (private members) from metadata-only assemblies.
+Ref assemblies will include an assembly-level `ReferenceAssembly` attribute. This attribute may be specified in source (then we won't need to synthesize it). Because of this attribute, runtimes will refuse to load ref assemblies for execution (but they can still be loaded Reflection-only mode).
+Ref assemblies further remove metadata (private members) from metadata-only assemblies:
 
-A reference assembly will only have references for what it needs in the API surface. The real assembly may have additional references related to specific implementations. For instance, the reference assembly for `class C { private void M() { dynamic .... } }` will not have any references for `dynamic` types.
-
-Private function-members (methods, properties and events) will be removed. If there are no `InternalsVisibleTo` attributes, do the same for internal function-members
-
-All types (including private or nested types) must be kept in reference assemblies.
-
-All fields of a struct will be kept (in C# 7.1 timeframe), but this can later be refined. There are three cases to consider (ref case, struct case, generic case), where we could possibly substitute the fields with adequate placeholders that would minimize the rate of change of the ref assembly.
-
-Reference assemblies will include an assembly-level `ReferenceAssembly` attribute. If such an attribute is found in source, we won't need to synthesize it. Because of this attribute, runtimes will refuse to load reference assemblies.
+- A ref assembly will only have references for what it needs in the API surface. The real assembly may have additional references related to specific implementations. For instance, the ref assembly for `class C { private void M() { dynamic d = 1; ... } }` will not reference any types required for `dynamic`.
+- Private function-members (methods, properties and events) will be removed. If there are no `InternalsVisibleTo` attributes, do the same for internal function-members
+- But all types (including private or nested types) must be kept in ref assemblies. All attributes must be kept (even internal ones).
+- All virtual methods will be kept. Explicit interface implementations will be kept.
+- All fields of a struct will be kept. (This is a candidate for post-C#-7.1 refinement)
 
 ## API changes
 
@@ -32,15 +30,16 @@ Two mutually exclusive command-line parameters will be added to `csc.exe` and `v
 - `/refout`
 - `/refonly`
 
-The `/refout` parameter specifies a file path where the ref assembly should be output. This translates to `metadataPeStream` in the `Emit` API (see details below). The filename for the ref assembly should generally match that of the primary assembly, but it can be in a different folder.
+The `/refout` parameter specifies a file path where the ref assembly should be output. This translates to `metadataPeStream` in the `Emit` API (see details below). The filename for the ref assembly should generally match that of the primary assembly (we will warn when they don't match). The recommended convention (used by MSBuild) is to place the ref assembly in a "ref/" sub-folder relative to the primary assembly.
 
-The `/refonly` parameter is a flag that indicates that a ref assembly should be output instead of an implementation assembly. 
+The `/refonly` parameter is a flag that indicates that a ref assembly should be output instead of an implementation assembly, as the primary output.
 The `/refonly` parameter is not allowed together with the `/refout` parameter, as it doesn't make sense to have both the primary and secondary outputs be ref assemblies. Also, the `/refonly` parameter silently disables outputting PDBs, as ref assemblies cannot be executed. 
 The `/refonly` parameter translates to `EmitMetadataOnly` being `true`, and `IncludePrivateMembers` being `false` in the `Emit` API (see details below).
-Neither `/refonly` nor `/refout` are permitted with `/target:module`, `/addmodule`, or `/link:...` options.
+Neither `/refonly` nor `/refout` are permitted with net modules (`/target:module`, `/addmodule` options).
 
 The compilation from the command-line will either produce both assemblies (implementation and ref) or neither. There is no "partial success" scenario.
-When the compiler produces documentation, it is un-affected by either the `/refonly` or `/refout` parameters.
+When the compiler produces documentation, it is un-affected by either the `/refonly` or `/refout` parameters. This may change in the future.
+The main purpose of the `/refout` option is to speed up incremental build scenarios. The current implementation for this flag can produce a ref assembly with more metadata than `/refonly` (for instance, anonymous types). This is a candidate for post-C#-7.1 refinement.
 
 ### CscTask/CoreCompile
 The `CoreCompile` target will support a new output, called `IntermediateRefAssembly`, which parallels the existing `IntermediateAssembly`.
@@ -49,6 +48,8 @@ Both of those basically map to the `/refout` command-line parameter.
 
 An additional task, called `CopyRefAssembly`, will be provided along with the existing `Csc` task. It takes a `SourcePath` and a `DestinationPath` and generally copies the file from the source over to the destination. But if it can determine that the contents of those two files match (by comparing their MVIDs, see details below), then the destination file is left untouched.
 
+As a side-note, `CopyRefAssembly` uses the same assembly resolution/redirection trick as `Csc` and `Vbc`, to avoid type loading problems with `System.IO.FileSystem`.
+
 ### CodeAnalysis APIs
 It is already possible to produce metadata-only assemblies by using `EmitOptions.EmitMetadataOnly`, which is used in IDE scenarios with cross-language dependencies.
 The compiler will be updated to honour the `EmitOptions.IncludePrivateMembers` flag as well. When combined with `EmitMetadataOnly` or a `metadataPeStream` in `Emit`, a ref assembly will be produced.
@@ -64,15 +65,12 @@ Going back to the 4 driving scenarios:
 
 ## Future
 As mentioned above, there may be further refinements after C# 7.1:
+- Further reduce the metadata in ref assemblies produced by `/refout`, to match those produced by `/refonly`.
 - Controlling internals (producing public ref assemblies)
 - Produce ref assemblies even when there are errors outside method bodies (emitting error types when `EmitOptions.TolerateErrors` is set)
 - When the compiler produces documentation, the contents produced could be filtered down to match the APIs that go into the primary output. In other words, the documentation could be filtered down when using the `/refonly` parameter.
 
-
 ## Open questions
-- should explicit method implementations be included in ref assemblies?
-- Non-public attributes on public APIs (emit attribute based on accessibility rule)
-- ref assemblies and NoPia
 
 ## Related issues
 - Produce ref assemblies from command-line and msbuild (https://github.com/dotnet/roslyn/issues/2184)
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
index 8ecf42d4f1745..e0330009414e0 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
+++ b/src/Compilers/CSharp/Portable/CSharpResources.Designer.cs
@@ -6730,15 +6730,6 @@ internal static string ERR_NoDynamicPhantomOnBaseIndexer {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot embed types when using /refout or /refonly..
-        /// </summary>
-        internal static string ERR_NoEmbeddedTypeWhenRefOutOrRefOnly {
-            get {
-                return ResourceManager.GetString("ERR_NoEmbeddedTypeWhenRefOutOrRefOnly", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to Program does not contain a static &apos;Main&apos; method suitable for an entry point.
         /// </summary>
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index abca5ec5f2823..e286576fa98bd 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -2303,9 +2303,6 @@ If such a class is used as a base class and if the deriving class defines a dest
   <data name="ERR_NoNetModuleOutputWhenRefOutOrRefOnly" xml:space="preserve">
     <value>Cannot compile net modules when using /refout or /refonly.</value>
   </data>
-  <data name="ERR_NoEmbeddedTypeWhenRefOutOrRefOnly" xml:space="preserve">
-    <value>Cannot embed types when using /refout or /refonly.</value>
-  </data>
   <data name="ERR_OvlOperatorExpected" xml:space="preserve">
     <value>Overloadable operator expected</value>
   </data>
diff --git a/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs b/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
index cbde4e6815d12..c28578c8eb9b5 100644
--- a/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
+++ b/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs
@@ -1178,11 +1178,6 @@ internal sealed override CommandLineArguments CommonParse(IEnumerable<string> ar
                 AddDiagnostic(diagnostics, diagnosticOptions, ErrorCode.ERR_NoRefOutWhenRefOnly);
             }
 
-            if ((refOnly || outputRefFilePath != null) && metadataReferences.Any(r => r.Properties.EmbedInteropTypes))
-            {
-                AddDiagnostic(diagnostics, diagnosticOptions, ErrorCode.ERR_NoEmbeddedTypeWhenRefOutOrRefOnly);
-            }
-
             if (outputKind == OutputKind.NetModule && (refOnly || outputRefFilePath != null))
             {
                 AddDiagnostic(diagnostics, diagnosticOptions, ErrorCode.ERR_NoNetModuleOutputWhenRefOutOrRefOnly);
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index fc6def429db0c..b3c1a489e22fc 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -1481,7 +1481,7 @@ internal enum ErrorCode
 
         ERR_NoRefOutWhenRefOnly = 8308,
         ERR_NoNetModuleOutputWhenRefOutOrRefOnly = 8309,
-        ERR_NoEmbeddedTypeWhenRefOutOrRefOnly = 8310,
+        // Available = 8310,
         ERR_BadDynamicMethodArgDefaultLiteral = 8311,
         ERR_DefaultLiteralNotValid = 8312,
         WRN_DefaultInSwitch = 8313,
diff --git a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
index 616e19367c623..3c72b5364eace 100644
--- a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
+++ b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
@@ -2887,16 +2887,10 @@ public void ParseOut()
                 Diagnostic(ErrorCode.ERR_NoRefOutWhenRefOnly).WithLocation(1, 1));
 
             parsedArgs = DefaultParse(new[] { @"/refout:ref.dll", "/link:b", "a.cs" }, baseDirectory);
-            parsedArgs.Errors.Verify(
-                // error CS8357: Cannot embed types when using /refout or /refonly.
-                Diagnostic(ErrorCode.ERR_NoEmbeddedTypeWhenRefOutOrRefOnly).WithLocation(1, 1)
-                );
+            parsedArgs.Errors.Verify();
 
             parsedArgs = DefaultParse(new[] { "/refonly", "/link:b", "a.cs" }, baseDirectory);
-            parsedArgs.Errors.Verify(
-                // error CS8357: Cannot embed types when using /refout or /refonly.
-                Diagnostic(ErrorCode.ERR_NoEmbeddedTypeWhenRefOutOrRefOnly).WithLocation(1, 1)
-                );
+            parsedArgs.Errors.Verify();
 
             parsedArgs = DefaultParse(new[] { "/refonly:incorrect", "a.cs" }, baseDirectory);
             parsedArgs.Errors.Verify(
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
index dfe2050db72b5..db307fc169220 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
@@ -12,6 +12,7 @@
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.Test.Utilities;
@@ -614,6 +615,191 @@ public class C
             CompareAssemblies(sourceTemplate, left, right, expectedMatch, includePrivateMembers: false);
         }
 
+        [ConditionalFact(typeof(ClrOnly), typeof(DesktopOnly))]
+        public void RefAssembly_NoPia()
+        {
+            string piaSource = @"
+using System;
+using System.Runtime.InteropServices;
+
+[assembly: Guid(""f9c2d51d-4f44-45f0-9eda-c9d599b58257"")]
+[assembly: ImportedFromTypeLib(""Pia1.dll"")]
+
+public struct S { public int field; }
+
+[ComImport()]
+[Guid(""f9c2d51d-4f44-45f0-9eda-c9d599b58280"")]
+public interface ITest1
+{
+    S M();
+}";
+
+            var pia = CreateStandardCompilation(piaSource, options: TestOptions.ReleaseDll, assemblyName: "pia");
+            pia.VerifyEmitDiagnostics();
+
+            string source = @"
+public class D : ITest1
+{
+    public S M()
+    {
+        throw null;
+    }
+}
+";
+            var piaImageReference = pia.EmitToImageReference(embedInteropTypes: true);
+            verifyRefOnly(piaImageReference);
+            verifyRefOut(piaImageReference);
+
+            var piaMetadataReference = pia.ToMetadataReference(embedInteropTypes: true);
+            verifyRefOnly(piaMetadataReference);
+            verifyRefOut(piaMetadataReference);
+
+            void verifyRefOnly(MetadataReference reference)
+            {
+                var comp = CreateStandardCompilation(source, options: TestOptions.ReleaseDll,
+                                references: new MetadataReference[] { reference });
+                var refOnlyImage = EmitRefOnly(comp);
+                verifyNoPia(refOnlyImage);
+            }
+
+            void verifyRefOut(MetadataReference reference)
+            {
+                var comp = CreateStandardCompilation(source, options: TestOptions.DebugDll,
+                                references: new MetadataReference[] { reference });
+                var (image, refImage) = EmitRefOut(comp);
+                verifyNoPia(image);
+                verifyNoPia(refImage);
+            }
+
+            void verifyNoPia(ImmutableArray<byte> image)
+            {
+                var reference = CompilationVerifier.LoadTestEmittedExecutableForSymbolValidation(image, OutputKind.DynamicallyLinkedLibrary);
+                var comp = CreateStandardCompilation("", references: new[] { reference });
+                var referencedAssembly = comp.GetReferencedAssemblySymbol(reference);
+                var module = (PEModuleSymbol)referencedAssembly.Modules[0];
+
+                var itest1 = module.GlobalNamespace.GetMember<NamedTypeSymbol>("ITest1");
+                Assert.NotNull(itest1.GetAttribute("System.Runtime.InteropServices", "TypeIdentifierAttribute"));
+
+                var method = (PEMethodSymbol)itest1.GetMember("M");
+                Assert.Equal("S ITest1.M()", method.ToTestDisplayString());
+
+                var s = (NamedTypeSymbol)method.ReturnType;
+                Assert.Equal("S", s.ToTestDisplayString());
+                Assert.NotNull(s.GetAttribute("System.Runtime.InteropServices", "TypeIdentifierAttribute"));
+
+                var field = s.GetMember("field");
+                Assert.Equal("System.Int32 S.field", field.ToTestDisplayString());
+            }
+        }
+
+        [ConditionalFact(typeof(ClrOnly), typeof(DesktopOnly))]
+        public void RefAssembly_NoPia_ReferenceFromMethodBody()
+        {
+            string piaSource = @"
+using System;
+using System.Runtime.InteropServices;
+
+[assembly: Guid(""f9c2d51d-4f44-45f0-9eda-c9d599b58257"")]
+[assembly: ImportedFromTypeLib(""Pia1.dll"")]
+
+public struct S { public int field; }
+
+[ComImport()]
+[Guid(""f9c2d51d-4f44-45f0-9eda-c9d599b58280"")]
+public interface ITest1
+{
+    S M();
+}";
+
+            var pia = CreateStandardCompilation(piaSource, options: TestOptions.ReleaseDll, assemblyName: "pia");
+            pia.VerifyEmitDiagnostics();
+
+            string source = @"
+public class D
+{
+    public void M2()
+    {
+        ITest1 x = null;
+        S s = x.M();
+    }
+}
+";
+            var piaImageReference = pia.EmitToImageReference(embedInteropTypes: true);
+            verifyRefOnly(piaImageReference);
+            verifyRefOut(piaImageReference);
+
+            var piaMetadataReference = pia.ToMetadataReference(embedInteropTypes: true);
+            verifyRefOnly(piaMetadataReference);
+            verifyRefOut(piaMetadataReference);
+
+            void verifyRefOnly(MetadataReference reference)
+            {
+                var comp = CreateStandardCompilation(source, options: TestOptions.ReleaseDll,
+                                references: new MetadataReference[] { reference });
+                using (var output = new MemoryStream())
+                {
+                    EmitResult emitResult = comp.Emit(output,
+                        options: new EmitOptions(includePrivateMembers: false).WithEmitMetadataOnly(true));
+                    Assert.True(emitResult.Success);
+                    emitResult.Diagnostics.Verify();
+
+                    var refImage = output.ToImmutable();
+                    verifyNoPia(refImage, expectMissing: true);
+                }
+            }
+
+            void verifyRefOut(MetadataReference reference)
+            {
+                var comp = CreateStandardCompilation(source, options: TestOptions.ReleaseDll,
+                                references: new MetadataReference[] { reference });
+                using (var output = new MemoryStream())
+                using (var metadataOutput = new MemoryStream())
+                {
+                    EmitResult emitResult = comp.Emit(output, metadataPEStream: metadataOutput,
+                        options: new EmitOptions(includePrivateMembers: false));
+                    Assert.True(emitResult.Success);
+                    emitResult.Diagnostics.Verify();
+
+                    var image = output.ToImmutable();
+                    var refImage = metadataOutput.ToImmutable();
+
+                    verifyNoPia(image, expectMissing: false);
+                    verifyNoPia(refImage, expectMissing: false);
+                }
+            }
+
+            // The ref assembly produced by refout has more types than that produced by refonly,
+            // because refout will bind the method bodies (and therefore populate more referenced types).
+            // This will be refined in the future. Follow-up issue: https://github.com/dotnet/roslyn/issues/19403
+            void verifyNoPia(ImmutableArray<byte> image, bool expectMissing)
+            {
+                var reference = CompilationVerifier.LoadTestEmittedExecutableForSymbolValidation(image, OutputKind.DynamicallyLinkedLibrary);
+                var comp = CreateStandardCompilation("", references: new[] { reference });
+                var referencedAssembly = comp.GetReferencedAssemblySymbol(reference);
+                var module = (PEModuleSymbol)referencedAssembly.Modules[0];
+
+                var itest1 = module.GlobalNamespace.GetMember<NamedTypeSymbol>("ITest1");
+                if (expectMissing)
+                {
+                    Assert.Null(itest1);
+                    Assert.Null(module.GlobalNamespace.GetMember<NamedTypeSymbol>("S"));
+                    return;
+                }
+
+                Assert.NotNull(itest1.GetAttribute("System.Runtime.InteropServices", "TypeIdentifierAttribute").ToString());
+
+                var method = (PEMethodSymbol)itest1.GetMember("M");
+                Assert.Equal("S ITest1.M()", method.ToTestDisplayString());
+
+                var s = (NamedTypeSymbol)method.ReturnType;
+                Assert.Equal("S", s.ToTestDisplayString());
+
+                var field = s.GetMember("field");
+                Assert.Equal("System.Int32 S.field", field.ToTestDisplayString());
+            }
+        }
+
         [Theory]
         [InlineData("internal void M() { }", "", Match.Different)]
         public void RefAssembly_InvariantToSomeChangesWithInternalsVisibleTo(string left, string right, Match expectedMatch)
@@ -864,54 +1050,158 @@ private static void VerifyRefAssemblyClient(string lib_cs, string source, Action
         }
 
         [Theory]
-        [InlineData("")]
-        [InlineData(@"[assembly: System.Reflection.AssemblyVersion(""1"")]")]
-        [InlineData(@"[assembly: System.Reflection.AssemblyVersion(""1.0.*"")]")]
-        public void RefAssembly_EmitAsDeterministic(string source)
-        {
-            var comp = CreateStandardCompilation(source, options: TestOptions.DebugDll.WithDeterministic(false));
+        [InlineData("", false)]
+        [InlineData(@"[assembly: System.Reflection.AssemblyVersion(""1"")]", false)]
+        [InlineData(@"[assembly: System.Reflection.AssemblyVersion(""1.0.0.*"")]", true)]
+        public void RefAssembly_EmitAsDeterministic(string source, bool hasWildcard)
+        {
+            var name = GetUniqueName();
+            var options = TestOptions.DebugDll.WithDeterministic(false);
+            var comp1 = CreateStandardCompilation(source, options: options, assemblyName: name);
+
+            var (out1, refOut1) = EmitRefOut(comp1);
+            var refOnly1 = EmitRefOnly(comp1);
+            VerifyIdentitiesMatch(out1, refOut1);
+            VerifyIdentitiesMatch(out1, refOnly1);
+            AssertEx.Equal(refOut1, refOut1);
+
+            // The resolution of the PE header time date stamp is seconds (divided by two), and we want to make sure that has an opportunity to change
+            // between calls to Emit.
+            Thread.Sleep(TimeSpan.FromSeconds(3));
 
-            var (image1, refImage1) = emitRefOut();
+            // Re-using the same compilation results in the same time stamp
+            var (out15, refOut15) = EmitRefOut(comp1);
+            VerifyIdentitiesMatch(out1, out15);
+            VerifyIdentitiesMatch(refOut1, refOut15);
+            AssertEx.Equal(refOut1, refOut15);
 
-            // The resolution of the PE header time date stamp is seconds, and we want to make sure that has an opportunity to change
-            // between calls to Emit.
-            Thread.Sleep(TimeSpan.FromSeconds(1));
-            var (image2, refImage2) = emitRefOut();
-            var refImage3 = emitRefOnly();
+            // Using a new compilation results in new time stamp
+            var comp2 = CreateStandardCompilation(source, options: options, assemblyName: name);
+            var (out2, refOut2) = EmitRefOut(comp2);
+            var refOnly2 = EmitRefOnly(comp2);
+            VerifyIdentitiesMatch(out2, refOut2);
+            VerifyIdentitiesMatch(out2, refOnly2);
 
-            AssertEx.Equal(refImage1, refImage2);
-            AssertEx.Equal(refImage1, refImage3);
+            VerifyIdentitiesMatch(out1, out2, expectMatch: !hasWildcard);
+            VerifyIdentitiesMatch(refOut1, refOut2, expectMatch: !hasWildcard);
 
-            var comp2 = CreateStandardCompilation(source, options: TestOptions.DebugDll.WithDeterministic(false));
-            var refImage4 = emitRefOnly();
-            AssertEx.Equal(refImage1, refImage4);
+            if (hasWildcard)
+            {
+                AssertEx.NotEqual(refOut1, refOut2);
+                AssertEx.NotEqual(refOut1, refOnly2);
+            }
+            else
+            {
+                // If no wildcards, the binaries are emitted deterministically
+                AssertEx.Equal(refOut1, refOut2);
+                AssertEx.Equal(refOut1, refOnly2);
+            }
+        }
 
-            (ImmutableArray<byte> image, ImmutableArray<byte> refImage) emitRefOut()
+        private void VerifySigned(ImmutableArray<byte> image, bool expectSigned = true)
+        {
+            using (var reader = new PEReader(image))
             {
-                using (var output = new MemoryStream())
-                using (var metadataOutput = new MemoryStream())
-                {
-                    var options = EmitOptions.Default.WithIncludePrivateMembers(false);
-                    comp.VerifyEmitDiagnostics();
-                    var result = comp.Emit(output, metadataPEStream: metadataOutput,
-                        options: options);
-                    return (output.ToImmutable(), metadataOutput.ToImmutable());
-                }
+                var flags = reader.PEHeaders.CorHeader.Flags;
+                Assert.Equal(expectSigned, flags.HasFlag(CorFlags.StrongNameSigned));
             }
+        }
 
-            ImmutableArray<byte> emitRefOnly()
+        private static void VerifyIdentitiesMatch(ImmutableArray<byte> firstImage, ImmutableArray<byte> secondImage,
+            bool expectMatch = true, bool expectPublicKey = false)
+        {
+            var id1 = ModuleMetadata.CreateFromImage(firstImage).GetMetadataReader().ReadAssemblyIdentityOrThrow();
+            var id2 = ModuleMetadata.CreateFromImage(secondImage).GetMetadataReader().ReadAssemblyIdentityOrThrow();
+            Assert.Equal(expectMatch, id1 == id2);
+            if (expectPublicKey)
             {
-                using (var output = new MemoryStream())
-                {
-                    var options = EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false);
-                    comp.VerifyEmitDiagnostics();
-                    var result = comp.Emit(output,
-                        options: options);
-                    return output.ToImmutable();
-                }
+                Assert.True(id1.HasPublicKey);
+                Assert.True(id2.HasPublicKey);
             }
         }
 
+        private static (ImmutableArray<byte> image, ImmutableArray<byte> refImage) EmitRefOut(CSharpCompilation comp)
+        {
+            using (var output = new MemoryStream())
+            using (var metadataOutput = new MemoryStream())
+            {
+                var options = EmitOptions.Default.WithIncludePrivateMembers(false);
+                comp.VerifyEmitDiagnostics();
+                var result = comp.Emit(output, metadataPEStream: metadataOutput,
+                    options: options);
+                return (output.ToImmutable(), metadataOutput.ToImmutable());
+            }
+        }
+
+        private static ImmutableArray<byte> EmitRefOnly(CSharpCompilation comp)
+        {
+            using (var output = new MemoryStream())
+            {
+                var options = EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false);
+                comp.VerifyEmitDiagnostics();
+                var result = comp.Emit(output,
+                    options: options);
+                return output.ToImmutable();
+            }
+        }
+
+        [Fact]
+        public void RefAssembly_PublicSigning()
+        {
+            var snk = Temp.CreateFile().WriteAllBytes(TestResources.General.snKey);
+
+            var comp = CreateStandardCompilation("public class C{}",
+                options: TestOptions.ReleaseDll.WithCryptoKeyFile(snk.Path).WithPublicSign(true));
+
+            comp.VerifyDiagnostics();
+            var (image, refImage) = EmitRefOut(comp);
+            var refOnlyImage = EmitRefOnly(comp);
+            VerifySigned(image);
+            VerifySigned(refImage);
+            VerifySigned(refOnlyImage);
+            VerifyIdentitiesMatch(image, refImage, expectPublicKey: true);
+            VerifyIdentitiesMatch(image, refOnlyImage, expectPublicKey: true);
+        }
+
+        [Fact]
+        public void RefAssembly_StrongNameProvider()
+        {
+            var signedDllOptions = TestOptions.ReleaseDll.
+                 WithCryptoKeyFile(SigningTestHelpers.KeyPairFile).
+                 WithStrongNameProvider(new SigningTestHelpers.VirtualizedStrongNameProvider(ImmutableArray<string>.Empty));
+
+            var comp = CreateStandardCompilation("public class C{}", options: signedDllOptions);
+
+            comp.VerifyDiagnostics();
+            var (image, refImage) = EmitRefOut(comp);
+            var refOnlyImage = EmitRefOnly(comp);
+            VerifySigned(image);
+            VerifySigned(refImage);
+            VerifySigned(refOnlyImage);
+            VerifyIdentitiesMatch(image, refImage, expectPublicKey: true);
+            VerifyIdentitiesMatch(image, refOnlyImage, expectPublicKey: true);
+        }
+
+        [Fact]
+        public void RefAssembly_StrongNameProviderAndDelaySign()
+        {
+            var signedDllOptions = TestOptions.ReleaseDll
+                .WithCryptoKeyFile(SigningTestHelpers.KeyPairFile)
+                .WithDelaySign(true)
+                .WithStrongNameProvider(new SigningTestHelpers.VirtualizedStrongNameProvider(ImmutableArray<string>.Empty));
+
+            var comp = CreateStandardCompilation("public class C{}", options: signedDllOptions);
+
+            comp.VerifyDiagnostics();
+            var (image, refImage) = EmitRefOut(comp);
+            var refOnlyImage = EmitRefOnly(comp);
+            VerifySigned(image, expectSigned: false);
+            VerifySigned(refImage, expectSigned: false);
+            VerifySigned(refOnlyImage, expectSigned: false);
+            VerifyIdentitiesMatch(image, refImage, expectPublicKey: true);
+            VerifyIdentitiesMatch(image, refOnlyImage, expectPublicKey: true);
+        }
+
         [Theory]
         [InlineData("public int M() { error(); }", true)]
         [InlineData("public int M() { error() }", false)] // This may get relaxed. See follow-up issue https://github.com/dotnet/roslyn/issues/17612
@@ -952,7 +1242,7 @@ void VerifyIgnoresDiagnostics(EmitOptions emitOptions, bool success)
         }
 
         [Fact]
-        public void VerifyRefAssembly()
+        public void RefAssembly_VerifyTypesAndMembers()
         {
             string source = @"
 public class PublicClass
@@ -961,6 +1251,8 @@ public class PublicClass
     private void PrivateMethod() { System.Console.Write(""Hello""); }
     protected void ProtectedMethod() { System.Console.Write(""Hello""); }
     internal void InternalMethod() { System.Console.Write(""Hello""); }
+    public event System.Action PublicEvent;
+    internal event System.Action InternalEvent;
 }
 ";
             CSharpCompilation comp = CreateCompilation(source, references: new[] { MscorlibRef },
@@ -979,7 +1271,10 @@ public class PublicClass
             AssertEx.Equal(
                 new[] { "void PublicClass.PublicMethod()", "void PublicClass.PrivateMethod()",
                     "void PublicClass.ProtectedMethod()", "void PublicClass.InternalMethod()",
-                    "PublicClass..ctor()" },
+                    "void PublicClass.PublicEvent.add", "void PublicClass.PublicEvent.remove",
+                    "void PublicClass.InternalEvent.add", "void PublicClass.InternalEvent.remove",
+                    "PublicClass..ctor()",
+                    "event System.Action PublicClass.PublicEvent", "event System.Action PublicClass.InternalEvent" },
                 compWithReal.GetMember<NamedTypeSymbol>("PublicClass").GetMembers()
                     .Select(m => m.ToTestDisplayString()));
 
@@ -1003,7 +1298,10 @@ public class PublicClass
             AssertEx.Equal(
                 new[] { "void PublicClass.PublicMethod()", "void PublicClass.PrivateMethod()",
                     "void PublicClass.ProtectedMethod()", "void PublicClass.InternalMethod()",
-                    "PublicClass..ctor()" },
+                    "void PublicClass.PublicEvent.add", "void PublicClass.PublicEvent.remove",
+                    "void PublicClass.InternalEvent.add", "void PublicClass.InternalEvent.remove",
+                    "PublicClass..ctor()",
+                    "event System.Action PublicClass.PublicEvent", "event System.Action PublicClass.InternalEvent" },
                 compWithMetadata.GetMember<NamedTypeSymbol>("PublicClass").GetMembers().Select(m => m.ToTestDisplayString()));
 
             AssertEx.Equal(
@@ -1014,7 +1312,7 @@ public class PublicClass
 
             MetadataReaderUtils.AssertEmptyOrThrowNull(comp.EmitToArray(emitMetadataOnly));
 
-            // verify metadata (types, members, attributes) of the metadata-only assembly
+            // verify metadata (types, members, attributes) of the ref assembly
             var emitRefOnly = EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false);
             CompileAndVerify(comp, emitOptions: emitRefOnly, verify: true);
 
@@ -1026,7 +1324,9 @@ public class PublicClass
                 compWithRef.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMembers().Select(m => m.ToDisplayString()));
 
             AssertEx.Equal(
-                new[] { "void PublicClass.PublicMethod()", "void PublicClass.ProtectedMethod()", "PublicClass..ctor()" },
+                new[] { "void PublicClass.PublicMethod()", "void PublicClass.ProtectedMethod()",
+                    "void PublicClass.PublicEvent.add", "void PublicClass.PublicEvent.remove",
+                    "PublicClass..ctor()", "event System.Action PublicClass.PublicEvent"},
                 compWithRef.GetMember<NamedTypeSymbol>("PublicClass").GetMembers().Select(m => m.ToTestDisplayString()));
 
             AssertEx.Equal(
@@ -1040,6 +1340,34 @@ public class PublicClass
             MetadataReaderUtils.AssertEmptyOrThrowNull(comp.EmitToArray(emitRefOnly));
         }
 
+        [Fact]
+        public void RefAssembly_VerifyTypesAndMembersOnStruct()
+        {
+            string source = @"
+internal struct InternalStruct
+{
+    internal int P { get; set; }
+}
+";
+            CSharpCompilation comp = CreateCompilation(source, references: new[] { MscorlibRef },
+                options: TestOptions.DebugDll.WithDeterministic(true));
+
+            // verify metadata (types, members, attributes) of the ref assembly
+            var emitRefOnly = EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false);
+            CompileAndVerify(comp, emitOptions: emitRefOnly, verify: true);
+
+            var refImage = comp.EmitToImageReference(emitRefOnly);
+            var compWithRef = CreateCompilation("", references: new[] { MscorlibRef, refImage },
+                options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
+            AssertEx.Equal(
+                new[] { "<Module>", "InternalStruct" },
+                compWithRef.SourceModule.GetReferencedAssemblySymbols().Last().GlobalNamespace.GetMembers().Select(m => m.ToDisplayString()));
+
+            AssertEx.Equal(
+                new[] { "System.Int32 InternalStruct.<P>k__BackingField", "InternalStruct..ctor()" },
+                compWithRef.GetMember<NamedTypeSymbol>("InternalStruct").GetMembers().Select(m => m.ToTestDisplayString()));
+        }
+
         [Fact]
         public void EmitMetadataOnly_DisallowPdbs()
         {
@@ -1149,30 +1477,6 @@ public void EmitMetadataOnly_DisallowEmbeddingPdb()
             }
         }
 
-        [Fact]
-        public void RefAssembly_DisallowEmbeddingTypes()
-        {
-            CSharpCompilation comp = CreateCompilation("", options: TestOptions.DebugDll,
-                references: new MetadataReference[]
-                {
-                    TestReferences.SymbolsTests.NoPia.GeneralPia.WithEmbedInteropTypes(true)
-                });
-
-            using (var output = new MemoryStream())
-            {
-                Assert.Throws<ArgumentException>(() => comp.Emit(output,
-                    options: EmitOptions.Default.WithEmitMetadataOnly(true).WithIncludePrivateMembers(false)));
-            }
-
-            using (var output = new MemoryStream())
-            using (var metadataOutput = new MemoryStream())
-            {
-                Assert.Throws<ArgumentException>(() => comp.Emit(output,
-                    metadataPEStream: metadataOutput,
-                    options: EmitOptions.Default.WithIncludePrivateMembers(false)));
-            }
-        }
-
         [Fact]
         public void EmitMetadata()
         {
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
index 61e4fd59a5707..d8aed8a10efe1 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.Designer.cs
@@ -477,15 +477,6 @@ internal static string EmbeddingPdbUnexpectedWhenEmittingMetadata {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Embedded interop type references should not be given when emitting a ref assembly..
-        /// </summary>
-        internal static string EmbedInteropTypesUnexpectedWhenEmittingRefAssembly {
-            get {
-                return ResourceManager.GetString("EmbedInteropTypesUnexpectedWhenEmittingRefAssembly", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to A key in the pathMap is empty..
         /// </summary>
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.resx b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
index cbf5f16a7c308..792684abef194 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.resx
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
@@ -333,9 +333,6 @@
   <data name="PdbStreamUnexpectedWhenEmittingMetadataOnly" xml:space="preserve">
     <value>PDB stream should not be given when emitting metadata only.</value>
   </data>
-  <data name="EmbedInteropTypesUnexpectedWhenEmittingRefAssembly" xml:space="preserve">
-    <value>Embedded interop type references should not be given when emitting a ref assembly.</value>
-  </data>
   <data name="MetadataPeStreamUnexpectedWhenEmittingMetadataOnly" xml:space="preserve">
     <value>Metadata PE stream should not be given when emitting metadata only.</value>
   </data>
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index be14eaa324e02..ed58f52d8d86d 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -2087,13 +2087,6 @@ public EmitResult Emit(
                 throw new ArgumentException(CodeAnalysisResources.IncludingPrivateMembersUnexpectedWhenEmittingToMetadataPeStream, nameof(metadataPEStream));
             }
 
-            if ((metadataPEStream != null || options?.EmitMetadataOnly == true) &&
-                options?.IncludePrivateMembers == false &&
-                References.Any(r => r.Properties.EmbedInteropTypes))
-            {
-                throw new ArgumentException(CodeAnalysisResources.EmbedInteropTypesUnexpectedWhenEmittingRefAssembly, nameof(metadataPEStream));
-            }
-
             if (options?.DebugInformationFormat == DebugInformationFormat.Embedded &&
                 options?.EmitMetadataOnly == true)
             {
diff --git a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
index 029a9e8b343a9..5f58fd2094c52 100644
--- a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
+++ b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCommandLineParser.vb
@@ -1203,10 +1203,6 @@ lVbRuntimePlus:
                 AddDiagnostic(diagnostics, ERRID.ERR_NoRefOutWhenRefOnly)
             End If
 
-            If (refOnly OrElse outputRefFileName IsNot Nothing) AndAlso metadataReferences.Any(Function(r) r.Properties.EmbedInteropTypes) Then
-                AddDiagnostic(diagnostics, ERRID.ERR_NoEmbeddedTypeWhenRefOutOrRefOnly)
-            End If
-
             If outputKind = OutputKind.NetModule AndAlso (refOnly OrElse outputRefFileName IsNot Nothing) Then
                 AddDiagnostic(diagnostics, ERRID.ERR_NoNetModuleOutputWhenRefOutOrRefOnly)
             End If
diff --git a/src/Compilers/VisualBasic/Portable/Errors/Errors.vb b/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
index e1354d47b40bd..5303649b024cf 100644
--- a/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
+++ b/src/Compilers/VisualBasic/Portable/Errors/Errors.vb
@@ -1733,7 +1733,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
         ERR_NoRefOutWhenRefOnly = 37300
         ERR_NoNetModuleOutputWhenRefOutOrRefOnly = 37301
-        ERR_NoEmbeddedTypeWhenRefOutOrRefOnly = 37302
 
         '// WARNINGS BEGIN HERE
         WRN_UseOfObsoleteSymbol2 = 40000
diff --git a/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb b/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb
index 19140e975e4dd..50815e2e104e2 100644
--- a/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb
+++ b/src/Compilers/VisualBasic/Portable/VBResources.Designer.vb
@@ -8070,15 +8070,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
         
-        '''<summary>
-        '''  Looks up a localized string similar to Cannot embed types when using /refout or /refonly..
-        '''</summary>
-        Friend ReadOnly Property ERR_NoEmbeddedTypeWhenRefOutOrRefOnly() As String
-            Get
-                Return ResourceManager.GetString("ERR_NoEmbeddedTypeWhenRefOutOrRefOnly", resourceCulture)
-            End Get
-        End Property
-        
         '''<summary>
         '''  Looks up a localized string similar to Array bounds cannot appear in type specifiers..
         '''</summary>
diff --git a/src/Compilers/VisualBasic/Portable/VBResources.resx b/src/Compilers/VisualBasic/Portable/VBResources.resx
index aa0c8d2866e81..d7239d6c732ba 100644
--- a/src/Compilers/VisualBasic/Portable/VBResources.resx
+++ b/src/Compilers/VisualBasic/Portable/VBResources.resx
@@ -5471,9 +5471,6 @@
   <data name="ERR_NoRefOutWhenRefOnly" xml:space="preserve">
     <value>Do not use refout when using refonly.</value>
   </data>
-  <data name="ERR_NoEmbeddedTypeWhenRefOutOrRefOnly" xml:space="preserve">
-    <value>Cannot embed types when using /refout or /refonly.</value>
-  </data>
   <data name="ERR_NoNetModuleOutputWhenRefOutOrRefOnly" xml:space="preserve">
     <value>Cannot compile net modules when using /refout or /refonly.</value>
   </data>
diff --git a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
index 0e3f43a3cdf81..caf04f3fa5cc1 100644
--- a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
+++ b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
@@ -2924,12 +2924,10 @@ print Goodbye, World"
                 Diagnostic(ERRID.ERR_NoNetModuleOutputWhenRefOutOrRefOnly).WithLocation(1, 1))
 
             parsedArgs = DefaultParse({"/refout:ref.dll", "/link:b", "a.vb"}, baseDirectory)
-            parsedArgs.Errors.Verify(
-                Diagnostic(ERRID.ERR_NoEmbeddedTypeWhenRefOutOrRefOnly).WithLocation(1, 1))
+            parsedArgs.Errors.Verify()
 
             parsedArgs = DefaultParse({"/refonly", "/link:b", "a.vb"}, baseDirectory)
-            parsedArgs.Errors.Verify(
-                Diagnostic(ERRID.ERR_NoEmbeddedTypeWhenRefOutOrRefOnly).WithLocation(1, 1))
+            parsedArgs.Errors.Verify()
 
             parsedArgs = DefaultParse({"/refonly", "/target:module", "a.vb"}, baseDirectory)
             parsedArgs.Errors.Verify(
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
index a2939a18115fa..493a56abe6ea4 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
@@ -774,7 +774,7 @@ End Class"
         End Sub
 
         <Fact>
-        Public Sub VerifyRefAssembly()
+        Public Sub RefAssembly_VerifyTypesAndMembers()
             Dim source = "
 Public MustInherit Class PublicClass
     Public Sub PublicMethod()
@@ -790,6 +790,8 @@ Public MustInherit Class PublicClass
         System.Console.Write(""Hello"")
     End Sub
     Public MustOverride Sub AbstractMethod()
+    Public Event PublicEvent As System.Action
+    Friend Event InternalEvent As System.Action
 End Class"
             Dim comp As Compilation = CreateCompilation(source, references:={MscorlibRef},
                             options:=TestOptions.DebugDll.WithDeterministic(True))
@@ -805,10 +807,14 @@ End Class"
                 {"<Module>", "PublicClass"},
                 realAssembly.GlobalNamespace.GetMembers().Select(Function(m) m.ToDisplayString()))
 
-            AssertEx.SetEqual(
-                {"Sub PublicClass.PublicMethod()", "Sub PublicClass.PrivateMethod()",
-                    "Sub PublicClass.InternalMethod()", "Sub PublicClass.ProtectedMethod()",
-                    "Sub PublicClass.AbstractMethod()", "Sub PublicClass..ctor()"},
+            AssertEx.Equal(
+                {"PublicClass.PublicEventEvent As System.Action", "PublicClass.InternalEventEvent As System.Action",
+                    "Sub PublicClass..ctor()", "Sub PublicClass.PublicMethod()",
+                    "Sub PublicClass.PrivateMethod()", "Sub PublicClass.ProtectedMethod()",
+                    "Sub PublicClass.InternalMethod()", "Sub PublicClass.AbstractMethod()",
+                    "Sub PublicClass.add_PublicEvent(obj As System.Action)", "Sub PublicClass.remove_PublicEvent(obj As System.Action)",
+                    "Sub PublicClass.add_InternalEvent(obj As System.Action)", "Sub PublicClass.remove_InternalEvent(obj As System.Action)",
+                    "Event PublicClass.PublicEvent As System.Action", "Event PublicClass.InternalEvent As System.Action"},
                 compWithReal.GetMember(Of NamedTypeSymbol)("PublicClass").GetMembers().
                     Select(Function(m) m.ToTestDisplayString()))
 
@@ -830,10 +836,14 @@ End Class"
                 {"<Module>", "PublicClass"},
                 metadataAssembly.GlobalNamespace.GetMembers().Select(Function(m) m.ToDisplayString()))
 
-            AssertEx.SetEqual(
-                {"Sub PublicClass.PublicMethod()", "Sub PublicClass.PrivateMethod()",
-                    "Sub PublicClass.InternalMethod()", "Sub PublicClass.ProtectedMethod()",
-                    "Sub PublicClass.AbstractMethod()", "Sub PublicClass..ctor()"},
+            AssertEx.Equal(
+                {"PublicClass.PublicEventEvent As System.Action", "PublicClass.InternalEventEvent As System.Action",
+                    "Sub PublicClass..ctor()", "Sub PublicClass.PublicMethod()",
+                    "Sub PublicClass.PrivateMethod()", "Sub PublicClass.ProtectedMethod()",
+                    "Sub PublicClass.InternalMethod()", "Sub PublicClass.AbstractMethod()",
+                    "Sub PublicClass.add_PublicEvent(obj As System.Action)", "Sub PublicClass.remove_PublicEvent(obj As System.Action)",
+                    "Sub PublicClass.add_InternalEvent(obj As System.Action)", "Sub PublicClass.remove_InternalEvent(obj As System.Action)",
+                    "Event PublicClass.PublicEvent As System.Action", "Event PublicClass.InternalEvent As System.Action"},
                 compWithMetadata.GetMember(Of NamedTypeSymbol)("PublicClass").GetMembers().
                     Select(Function(m) m.ToTestDisplayString()))
 
@@ -845,7 +855,7 @@ End Class"
 
             MetadataReaderUtils.AssertEmptyOrThrowNull(comp.EmitToArray(emitMetadataOnly))
 
-            ' verify metadata (types, members, attributes) of the metadata-only assembly
+            ' verify metadata (types, members, attributes) of the ref assembly
             Dim emitRefOnly = EmitOptions.Default.WithEmitMetadataOnly(True).WithIncludePrivateMembers(False)
             CompileAndVerify(comp, emitOptions:=emitRefOnly, verify:=True)
 
@@ -859,7 +869,9 @@ End Class"
 
             AssertEx.SetEqual(
                 {"Sub PublicClass..ctor()", "Sub PublicClass.PublicMethod()",
-                    "Sub PublicClass.ProtectedMethod()", "Sub PublicClass.AbstractMethod()"},
+                    "Sub PublicClass.ProtectedMethod()", "Sub PublicClass.AbstractMethod()",
+                    "Sub PublicClass.add_PublicEvent(obj As System.Action)", "Sub PublicClass.remove_PublicEvent(obj As System.Action)",
+                    "Event PublicClass.PublicEvent As System.Action"},
                 compWithRef.GetMember(Of NamedTypeSymbol)("PublicClass").GetMembers().
                     Select(Function(m) m.ToTestDisplayString()))
 
@@ -873,6 +885,35 @@ End Class"
             MetadataReaderUtils.AssertEmptyOrThrowNull(comp.EmitToArray(emitRefOnly))
         End Sub
 
+        <Fact>
+        Public Sub RefAssembly_VerifyTypesAndMembersOnStruct()
+            Dim source = "
+Friend Structure InternalStruct
+    Friend Property P As Integer
+End Structure"
+            Dim comp As Compilation = CreateCompilation(source, references:={MscorlibRef},
+                            options:=TestOptions.DebugDll.WithDeterministic(True))
+
+            Dim verifier = CompileAndVerify(comp, emitOptions:=EmitOptions.Default.WithEmitMetadataOnly(True), verify:=True)
+
+            ' verify metadata (types, members, attributes) of the ref assembly
+            Dim emitRefOnly = EmitOptions.Default.WithEmitMetadataOnly(True).WithIncludePrivateMembers(False)
+            CompileAndVerify(comp, emitOptions:=emitRefOnly, verify:=True)
+
+            Dim refImage = comp.EmitToImageReference(emitRefOnly)
+            Dim compWithRef = CreateCompilation("", references:={MscorlibRef, refImage},
+                            options:=TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All))
+            Dim refAssembly As AssemblySymbol = compWithRef.SourceModule.GetReferencedAssemblySymbols().Last()
+            AssertEx.SetEqual(
+                {"<Module>", "InternalStruct"},
+                refAssembly.GlobalNamespace.GetMembers().Select(Function(m) m.ToDisplayString()))
+
+            AssertEx.SetEqual(
+                {"Sub InternalStruct..ctor()", "InternalStruct._P As System.Int32"},
+                compWithRef.GetMember(Of NamedTypeSymbol)("InternalStruct").GetMembers().
+                    Select(Function(m) m.ToTestDisplayString()))
+        End Sub
+
         <Fact>
         Public Sub EmitMetadataOnly_DisallowPdbs()
             Dim comp = CreateCompilation("", references:={MscorlibRef},
@@ -886,24 +927,6 @@ End Class"
             End Using
         End Sub
 
-        <Fact>
-        Public Sub RefAssembly_DisallowEmbeddingTypes()
-            Dim comp = CreateCompilation("", references:={MscorlibRef.WithEmbedInteropTypes(True)},
-                            options:=TestOptions.DebugDll)
-
-            Using output As New MemoryStream()
-                Assert.Throws(Of ArgumentException)(Function() comp.Emit(output,
-                                    options:=EmitOptions.Default.WithEmitMetadataOnly(True).WithIncludePrivateMembers(False)))
-            End Using
-
-            Using output As New MemoryStream()
-                Using metadataOutput = New MemoryStream()
-                    Assert.Throws(Of ArgumentException)(Function() comp.Emit(output, metadataPEStream:=metadataOutput,
-                                        options:=EmitOptions.Default.WithIncludePrivateMembers(False)))
-                End Using
-            End Using
-        End Sub
-
         <Fact>
         Public Sub EmitMetadataOnly_DisallowMetadataPeStream()
             Dim comp = CreateCompilation("", references:={MscorlibRef},
diff --git a/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs b/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs
index 67a41c836262f..774c3c76da1c1 100644
--- a/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs
+++ b/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs
@@ -311,7 +311,7 @@ private IModuleSymbol GetModuleSymbolForEmittedImage(ImmutableArray<byte> peImag
                 return assemblies.Last();
             }
 
-            private static MetadataReference LoadTestEmittedExecutableForSymbolValidation(
+            internal static MetadataReference LoadTestEmittedExecutableForSymbolValidation(
                 ImmutableArray<byte> image,
                 OutputKind outputKind,
                 string display = null)

From f67c2474a3cb6bec0e5d5a320c370b9564a06be6 Mon Sep 17 00:00:00 2001
From: Tom Meschter <tom.meschter@microsoft.com>
Date: Thu, 11 May 2017 14:17:01 -0700
Subject: [PATCH 137/284] Filter projects based on language name

Avoids [VSO bug 433873](https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems/edit/433873).

When mapping an `IVsHierarchy` to the related Roslyn project we end up asking each project for its associated `IVsHierarchy` and checking if various properties match up with those on the "origin" hierarchy. The properties supported and the interpretation of their values varies from one project system to another. The `HierarchyItemToProjectIdMap` class was implemented when Roslyn only supported C# and VB projects, and was designed with those in mind. Now that TypeScript can also have Roslyn projects we need to filter out everything that isn't C# or VB or we risk asking for properties that aren't supported or possibly misinterpret the values.
---
 .../HierarchyItemToProjectIdMap.cs                    | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs b/src/VisualStudio/Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs
index 46c6e7688b7d1..4932a8941a31c 100644
--- a/src/VisualStudio/Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs
+++ b/src/VisualStudio/Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs
@@ -6,7 +6,6 @@
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
 using Microsoft.VisualStudio.Shell;
-using Microsoft.VisualStudio.Shell.Interop;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.SolutionExplorer
 {
@@ -47,6 +46,16 @@ public bool TryGetProjectId(IVsHierarchyItem hierarchyItem, string targetFramewo
             var project = _workspace.DeferredState.ProjectTracker.ImmutableProjects
                     .Where(p =>
                     {
+                        // We're about to access various properties of the IVsHierarchy associated with the project.
+                        // The properties supported and the interpretation of their values varies from one project system
+                        // to another. This code is designed with C# and VB in mind, so we need to filter out everything
+                        // else.
+                        if (p.Language != LanguageNames.CSharp
+                            && p.Language != LanguageNames.VisualBasic)
+                        {
+                            return false;
+                        }
+
                         // Here we try to match the hierarchy from Solution Explorer to a hierarchy from the Roslyn project.
                         // The canonical name of a hierarchy item must be unique _within_ an hierarchy, but since we're
                         // examining multiple hierarchies the canonical name could be the same. Indeed this happens when two

From 6e011f2cf3a45534c03abc42e782f48052a4e6fe Mon Sep 17 00:00:00 2001
From: Artur Spychaj <drognanar@gmail.com>
Date: Thu, 11 May 2017 14:10:49 -0700
Subject: [PATCH 138/284] Delete the PR branch if nothing to merge

---
 src/Tools/Github/GithubMergeTool/GithubMergeTool.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Tools/Github/GithubMergeTool/GithubMergeTool.cs b/src/Tools/Github/GithubMergeTool/GithubMergeTool.cs
index 6e489790b23ee..8435fcd924ff0 100644
--- a/src/Tools/Github/GithubMergeTool/GithubMergeTool.cs
+++ b/src/Tools/Github/GithubMergeTool/GithubMergeTool.cs
@@ -121,6 +121,8 @@ git push {prBranchName} --force
             // 422 (Unprocessable Entity) indicates there were no commits to merge
             if (response.StatusCode == (HttpStatusCode)422)
             {
+                // Delete the pr branch if the PR was not created.
+                await _client.DeleteAsync($"repos/{repoOwner}/{repoName}/git/refs/heads/{prBranchName}");
                 return response;
             }
 

From d5263256edc41bd07dff1ae26a3eb59593a958bb Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Thu, 11 May 2017 14:30:14 -0700
Subject: [PATCH 139/284] Disable all tests.

---
 .../VisualBasic/BasicEditAndContinue.cs            | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
index 9d486ff80858c..0a2f57426d424 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
@@ -23,7 +23,7 @@ public BasicEditAndContinue(VisualStudioInstanceFactory instanceFactory) : base(
 
         protected override string LanguageName => LanguageNames.VisualBasic;
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void UpdateActiveStatementLeafNode()
         {
             VisualStudio.Editor.SetText(@"
@@ -82,7 +82,7 @@ Catch ex As Exception
             VisualStudio.Editor.Verify.CurrentLineText("End Try");
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void EditLambdaExpression()
         {
             VisualStudio.Editor.SetText(@"
@@ -113,7 +113,7 @@ End Sub
             VisualStudio.ErrorList.Verify.NoBuildErrors();
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void EnCWhileDebuggingFromImmediateWindow()
         {
             VisualStudio.Editor.SetText(@"
@@ -177,7 +177,7 @@ End Module
             VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void MultiProjectDebuggingWhereNotAllModulesAreLoaded()
         {
             SetupMultiProjectSolution();
@@ -188,7 +188,7 @@ public void MultiProjectDebuggingWhereNotAllModulesAreLoaded()
             VisualStudio.ErrorList.Verify.NoErrors();
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void DocumentStateTrackingReadonlyInRunMode()
         {
             SetupMultiProjectSolution();
@@ -238,7 +238,7 @@ End Module
             VisualStudio.Editor.Verify.IsProjectItemDirty(expectedValue: false);
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void LocalsWindowUpdatesAfterLocalGetsItsTypeUpdatedDuringEnC()
         {
             VisualStudio.Editor.SetText(@"
@@ -261,7 +261,7 @@ End Module
             VisualStudio.LocalsWindow.Verify.CheckEntry("foo", "Single", "10");
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void LocalsWindowUpdatesCorrectlyDuringEnC()
         {
             VisualStudio.Editor.SetText(@"

From 125ac47e1ca1831093cb5152eb6d589e51111794 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Thu, 11 May 2017 14:31:31 -0700
Subject: [PATCH 140/284] Disable tests.

---
 .../VisualBasic/BasicEditAndContinue.cs            | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
index 9d486ff80858c..0a2f57426d424 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
@@ -23,7 +23,7 @@ public BasicEditAndContinue(VisualStudioInstanceFactory instanceFactory) : base(
 
         protected override string LanguageName => LanguageNames.VisualBasic;
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void UpdateActiveStatementLeafNode()
         {
             VisualStudio.Editor.SetText(@"
@@ -82,7 +82,7 @@ Catch ex As Exception
             VisualStudio.Editor.Verify.CurrentLineText("End Try");
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void EditLambdaExpression()
         {
             VisualStudio.Editor.SetText(@"
@@ -113,7 +113,7 @@ End Sub
             VisualStudio.ErrorList.Verify.NoBuildErrors();
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void EnCWhileDebuggingFromImmediateWindow()
         {
             VisualStudio.Editor.SetText(@"
@@ -177,7 +177,7 @@ End Module
             VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void MultiProjectDebuggingWhereNotAllModulesAreLoaded()
         {
             SetupMultiProjectSolution();
@@ -188,7 +188,7 @@ public void MultiProjectDebuggingWhereNotAllModulesAreLoaded()
             VisualStudio.ErrorList.Verify.NoErrors();
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void DocumentStateTrackingReadonlyInRunMode()
         {
             SetupMultiProjectSolution();
@@ -238,7 +238,7 @@ End Module
             VisualStudio.Editor.Verify.IsProjectItemDirty(expectedValue: false);
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void LocalsWindowUpdatesAfterLocalGetsItsTypeUpdatedDuringEnC()
         {
             VisualStudio.Editor.SetText(@"
@@ -261,7 +261,7 @@ End Module
             VisualStudio.LocalsWindow.Verify.CheckEntry("foo", "Single", "10");
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void LocalsWindowUpdatesCorrectlyDuringEnC()
         {
             VisualStudio.Editor.SetText(@"

From 5b693dfa003723bfe2d3bf4087bde1bae84a4fce Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Thu, 11 May 2017 14:32:52 -0700
Subject: [PATCH 141/284] Disable tests.

---
 .../VisualBasic/BasicEditAndContinue.cs            | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
index 9d486ff80858c..0a2f57426d424 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEditAndContinue.cs
@@ -23,7 +23,7 @@ public BasicEditAndContinue(VisualStudioInstanceFactory instanceFactory) : base(
 
         protected override string LanguageName => LanguageNames.VisualBasic;
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void UpdateActiveStatementLeafNode()
         {
             VisualStudio.Editor.SetText(@"
@@ -82,7 +82,7 @@ Catch ex As Exception
             VisualStudio.Editor.Verify.CurrentLineText("End Try");
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void EditLambdaExpression()
         {
             VisualStudio.Editor.SetText(@"
@@ -113,7 +113,7 @@ End Sub
             VisualStudio.ErrorList.Verify.NoBuildErrors();
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void EnCWhileDebuggingFromImmediateWindow()
         {
             VisualStudio.Editor.SetText(@"
@@ -177,7 +177,7 @@ End Module
             VisualStudio.Workspace.WaitForAsyncOperations(FeatureAttribute.Workspace);
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void MultiProjectDebuggingWhereNotAllModulesAreLoaded()
         {
             SetupMultiProjectSolution();
@@ -188,7 +188,7 @@ public void MultiProjectDebuggingWhereNotAllModulesAreLoaded()
             VisualStudio.ErrorList.Verify.NoErrors();
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void DocumentStateTrackingReadonlyInRunMode()
         {
             SetupMultiProjectSolution();
@@ -238,7 +238,7 @@ End Module
             VisualStudio.Editor.Verify.IsProjectItemDirty(expectedValue: false);
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void LocalsWindowUpdatesAfterLocalGetsItsTypeUpdatedDuringEnC()
         {
             VisualStudio.Editor.SetText(@"
@@ -261,7 +261,7 @@ End Module
             VisualStudio.LocalsWindow.Verify.CheckEntry("foo", "Single", "10");
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19441")]
         public void LocalsWindowUpdatesCorrectlyDuringEnC()
         {
             VisualStudio.Editor.SetText(@"

From 1da5b30a2628cd8168e7206e98cce9f2e031ecb4 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Thu, 11 May 2017 14:58:53 -0700
Subject: [PATCH 142/284] added comments

---
 .../Remote/Core/Services/SolutionService.cs   | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/src/Workspaces/Remote/Core/Services/SolutionService.cs b/src/Workspaces/Remote/Core/Services/SolutionService.cs
index 0a2019cb24af7..2e0f28ca0bbf0 100644
--- a/src/Workspaces/Remote/Core/Services/SolutionService.cs
+++ b/src/Workspaces/Remote/Core/Services/SolutionService.cs
@@ -59,6 +59,28 @@ private async Task<Solution> GetSolutionInternalAsync(Checksum solutionChecksum,
             }
         }
 
+        /// <summary>
+        /// SolutionService is designed to be stateless. if someone asks a solution (through solution checksum), 
+        /// it will create one and return the solution. the engine takes care of synching required data and creating a solution
+        /// correspoing to the given checksum.
+        /// 
+        /// but doing that from scratch all the time wil be expansive in terms of synching data, compilation being cached, file being parsed
+        /// and etc. so even if the service itself is stateless, internally it has several caches to improve perf of various parts.
+        /// 
+        /// first, it holds onto last solution got built. this will take care of common cases where multiple services running off same solution.
+        /// second, it uses assets cache to hold onto data just synched (within 3 min) so that if it requires to build new solution, 
+        ///         it can save some time to re-sync data which might just used by other solution.
+        /// third, it holds onto solution from primary branch from Host. and it will try to see whether it can build new solution off the
+        ///        primary solution it is holding onto. this will make many solution level cache to be re-used.
+        ///
+        /// the primary solution can be updated in 2 ways.
+        /// first, host will keep track of primary solution changes in host, and call OOP to synch to latest time to time.
+        /// second, engine keeps track of whether a certain request is for primary solution or not, and if it is, 
+        ///         it let that request to update primary solution cache to latest.
+        /// 
+        /// these 2 are complimentary to each other. #1 makes OOP's primary solution to be ready for next call (push), #2 makes OOP's primary
+        /// solution be not stale as much as possible. (pull)
+        /// </summary>
         private async Task<Solution> CreateSolution_NoLockAsync(Checksum solutionChecksum, bool fromPrimaryBranch, Solution baseSolution, CancellationToken cancellationToken)
         {
             var updater = new SolutionCreator(_assetService, baseSolution, cancellationToken);

From 88cc266e5441fbeaf49e6c2210f2356d763f0ee3 Mon Sep 17 00:00:00 2001
From: Shyam N <gnamboo@microsoft.com>
Date: Mon, 8 May 2017 18:56:39 -0700
Subject: [PATCH 143/284] Fix instrumentation for methods that have spans in
 multiple source files.

A single method could have spans in multiple source files. For example, synthesized constructors of partial types can have spans in multiple files if this type has field initializers in multiple files. Another example is methods with #line directives.

This change changes instrumentation for such methods - the instrumented IL for such methods will now include a call to a new overload of Microsoft.CodeAnalysis.Runtime.Instrumentation.CreatePayload() that accepts an array of file indices as opposed to single file index.
---
 .../DynamicAnalysisInjector.cs                | 213 ++++++++++++---
 .../DynamicAnalysisResourceTests.cs           |  25 +-
 .../DynamicInstrumentationTests.cs            | 248 ++++++++++++------
 .../Symbol/Symbols/MissingSpecialMember.cs    |   3 +-
 .../Core/Portable/WellKnownMember.cs          |   4 +-
 .../Core/Portable/WellKnownMembers.cs         |  17 +-
 .../DynamicAnalysisInjector.vb                | 192 ++++++++++++--
 .../DynamicAnalysisResourceTests.vb           |  53 ++--
 .../DynamicInstrumentationTests.vb            |  31 ++-
 .../WellKnownTypeValidationTests.vb           |   6 +-
 .../Desktop/InstrumentationChecker.cs         |  34 ++-
 11 files changed, 626 insertions(+), 200 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DynamicAnalysisInjector.cs b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DynamicAnalysisInjector.cs
index e1c54b14d9174..c2c73ba4c85fa 100644
--- a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DynamicAnalysisInjector.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DynamicAnalysisInjector.cs
@@ -1,12 +1,13 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using Microsoft.CodeAnalysis.CodeGen;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Roslyn.Utilities;
 using System.Collections.Immutable;
 using System.Diagnostics;
-using System;
+using System.Linq;
+using Microsoft.Cci;
+using Microsoft.CodeAnalysis.CodeGen;
+using Microsoft.CodeAnalysis.Collections;
+using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -18,7 +19,8 @@ internal sealed class DynamicAnalysisInjector : CompoundInstrumenter
     {
         private readonly MethodSymbol _method;
         private readonly BoundStatement _methodBody;
-        private readonly MethodSymbol _createPayload;
+        private readonly MethodSymbol _createPayloadForMethodsSpanningSingleFile;
+        private readonly MethodSymbol _createPayloadForMethodsSpanningMultipleFiles;
         private readonly ArrayBuilder<SourceSpan> _spansBuilder;
         private ImmutableArray<SourceSpan> _dynamicAnalysisSpans = ImmutableArray<SourceSpan>.Empty;
         private readonly BoundStatement _methodEntryInstrumentation;
@@ -28,7 +30,13 @@ internal sealed class DynamicAnalysisInjector : CompoundInstrumenter
         private readonly DebugDocumentProvider _debugDocumentProvider;
         private readonly SyntheticBoundNodeFactory _methodBodyFactory;
 
-        public static DynamicAnalysisInjector TryCreate(MethodSymbol method, BoundStatement methodBody, SyntheticBoundNodeFactory methodBodyFactory, DiagnosticBag diagnostics, DebugDocumentProvider debugDocumentProvider, Instrumenter previous)
+        public static DynamicAnalysisInjector TryCreate(
+            MethodSymbol method,
+            BoundStatement methodBody,
+            SyntheticBoundNodeFactory methodBodyFactory,
+            DiagnosticBag diagnostics,
+            DebugDocumentProvider debugDocumentProvider,
+            Instrumenter previous)
         {
             // Do not instrument implicitly-declared methods, except for constructors.
             // Instrument implicit constructors in order to instrument member initializers.
@@ -43,28 +51,54 @@ public static DynamicAnalysisInjector TryCreate(MethodSymbol method, BoundStatem
                 return null;
             }
 
-            MethodSymbol createPayload = GetCreatePayload(methodBodyFactory.Compilation, methodBody.Syntax, diagnostics);
+            MethodSymbol createPayloadForMethodsSpanningSingleFile = GetCreatePayloadOverload(
+                methodBodyFactory.Compilation,
+                WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile,
+                methodBody.Syntax,
+                diagnostics);
+
+            MethodSymbol createPayloadForMethodsSpanningMultipleFiles = GetCreatePayloadOverload(
+                methodBodyFactory.Compilation,
+                WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles,
+                methodBody.Syntax,
+                diagnostics);
 
             // Do not instrument any methods if CreatePayload is not present.
-            if ((object)createPayload == null)
+            if ((object)createPayloadForMethodsSpanningSingleFile == null || (object)createPayloadForMethodsSpanningMultipleFiles == null)
             {
                 return null;
             }
 
             // Do not instrument CreatePayload if it is part of the current compilation (which occurs only during testing).
             // CreatePayload will fail at run time with an infinite recursion if it is instrumented.
-            if (method.Equals(createPayload))
+            if (method.Equals(createPayloadForMethodsSpanningSingleFile) || method.Equals(createPayloadForMethodsSpanningMultipleFiles))
             {
                 return null;
             }
 
-            return new DynamicAnalysisInjector(method, methodBody, methodBodyFactory, createPayload, diagnostics, debugDocumentProvider, previous);
-        }
-
-        private DynamicAnalysisInjector(MethodSymbol method, BoundStatement methodBody, SyntheticBoundNodeFactory methodBodyFactory, MethodSymbol createPayload, DiagnosticBag diagnostics, DebugDocumentProvider debugDocumentProvider, Instrumenter previous)
-            : base(previous)
-        {
-            _createPayload = createPayload;
+            return new DynamicAnalysisInjector(
+                method,
+                methodBody,
+                methodBodyFactory,
+                createPayloadForMethodsSpanningSingleFile,
+                createPayloadForMethodsSpanningMultipleFiles,
+                diagnostics,
+                debugDocumentProvider,
+                previous);
+        }
+
+        private DynamicAnalysisInjector(
+            MethodSymbol method,
+            BoundStatement methodBody,
+            SyntheticBoundNodeFactory methodBodyFactory,
+            MethodSymbol createPayloadForMethodsSpanningSingleFile,
+            MethodSymbol createPayloadForMethodsSpanningMultipleFiles,
+            DiagnosticBag diagnostics,
+            DebugDocumentProvider debugDocumentProvider,
+            Instrumenter previous) : base(previous)
+        {
+            _createPayloadForMethodsSpanningSingleFile = createPayloadForMethodsSpanningSingleFile;
+            _createPayloadForMethodsSpanningMultipleFiles = createPayloadForMethodsSpanningMultipleFiles;
             _method = method;
             _methodBody = methodBody;
             _spansBuilder = ArrayBuilder<SourceSpan>.GetInstance();
@@ -129,6 +163,78 @@ private static bool IsExcludedFromCodeCoverage(MethodSymbol method)
             return false;
         }
 
+        private static BoundExpressionStatement GetCreatePayloadStatement(
+            ImmutableArray<SourceSpan> dynamicAnalysisSpans,
+            SyntaxNode methodBodySyntax,
+            LocalSymbol methodPayload,
+            MethodSymbol createPayloadForMethodsSpanningSingleFile,
+            MethodSymbol createPayloadForMethodsSpanningMultipleFiles,
+            BoundExpression mvid,
+            BoundExpression methodToken,
+            BoundExpression payloadSlot,
+            SyntheticBoundNodeFactory methodBodyFactory,
+            DebugDocumentProvider debugDocumentProvider)
+        {
+            MethodSymbol createPayloadOverload;
+            BoundExpression fileIndexOrIndicesArgument;
+
+            if (dynamicAnalysisSpans.IsEmpty)
+            {
+                createPayloadOverload = createPayloadForMethodsSpanningSingleFile;
+
+                // For a compiler generated method that has no 'real' spans, we emit the index for
+                // the document corresponding to the syntax node that is associated with its bound node.
+                var document = GetSourceDocument(debugDocumentProvider, methodBodySyntax);
+                fileIndexOrIndicesArgument = methodBodyFactory.SourceDocumentIndex(document);
+            }
+            else
+            {
+                var documents = PooledHashSet<DebugSourceDocument>.GetInstance();
+                var fileIndices = ArrayBuilder<BoundExpression>.GetInstance();
+
+                foreach (var span in dynamicAnalysisSpans)
+                {
+                    var document = span.Document;
+                    if (documents.Add(document))
+                    {
+                        fileIndices.Add(methodBodyFactory.SourceDocumentIndex(document));
+                    }
+                }
+
+                documents.Free();
+
+                // At this point, we should have at least one document since we have already
+                // handled the case where method has no 'real' spans (and therefore no documents) above.
+                if (fileIndices.Count == 1)
+                {
+                    createPayloadOverload = createPayloadForMethodsSpanningSingleFile;
+                    fileIndexOrIndicesArgument = fileIndices.Single();
+                }
+                else
+                {
+                    createPayloadOverload = createPayloadForMethodsSpanningMultipleFiles;
+
+                    // Order of elements in fileIndices should be deterministic because these
+                    // elements were added based on order of spans in dynamicAnalysisSpans above.
+                    fileIndexOrIndicesArgument = methodBodyFactory.Array(
+                        methodBodyFactory.SpecialType(SpecialType.System_Int32), fileIndices.ToImmutable());
+                }
+
+                fileIndices.Free();
+            }
+
+            return methodBodyFactory.Assignment(
+                methodBodyFactory.Local(methodPayload),
+                methodBodyFactory.Call(
+                    null,
+                    createPayloadOverload,
+                    mvid,
+                    methodToken,
+                    fileIndexOrIndicesArgument,
+                    payloadSlot,
+                    methodBodyFactory.Literal(dynamicAnalysisSpans.Length)));
+        }
+
         public override BoundStatement CreateBlockPrologue(BoundBlock original, out LocalSymbol synthesizedLocal)
         {
             BoundStatement previousPrologue = base.CreateBlockPrologue(original, out synthesizedLocal);
@@ -138,22 +244,50 @@ public override BoundStatement CreateBlockPrologue(BoundBlock original, out Loca
                 // In the future there will be multiple analysis kinds.
                 const int analysisKind = 0;
 
-                ArrayTypeSymbol modulePayloadType = ArrayTypeSymbol.CreateCSharpArray(_methodBodyFactory.Compilation.Assembly, _payloadType);
+                ArrayTypeSymbol modulePayloadType =
+                    ArrayTypeSymbol.CreateCSharpArray(_methodBodyFactory.Compilation.Assembly, _payloadType);
 
                 // Synthesize the initialization of the instrumentation payload array, using concurrency-safe code:
                 //
                 // var payload = PID.PayloadRootField[methodIndex];
                 // if (payload == null)
-                //     payload = Instrumentation.CreatePayload(mvid, methodIndex, fileIndex, ref PID.PayloadRootField[methodIndex], payloadLength);
+                //     payload = Instrumentation.CreatePayload(mvid, methodIndex, fileIndexOrIndices, ref PID.PayloadRootField[methodIndex], payloadLength);
+
+                BoundStatement payloadInitialization =
+                    _methodBodyFactory.Assignment(
+                        _methodBodyFactory.Local(_methodPayload),
+                        _methodBodyFactory.ArrayAccess(
+                            _methodBodyFactory.InstrumentationPayloadRoot(analysisKind, modulePayloadType),
+                            ImmutableArray.Create(_methodBodyFactory.MethodDefIndex(_method))));
 
-                BoundStatement payloadInitialization = _methodBodyFactory.Assignment(_methodBodyFactory.Local(_methodPayload), _methodBodyFactory.ArrayAccess(_methodBodyFactory.InstrumentationPayloadRoot(analysisKind, modulePayloadType), ImmutableArray.Create(_methodBodyFactory.MethodDefIndex(_method))));
                 BoundExpression mvid = _methodBodyFactory.ModuleVersionId();
                 BoundExpression methodToken = _methodBodyFactory.MethodDefIndex(_method);
-                BoundExpression fileIndex = _methodBodyFactory.SourceDocumentIndex(GetSourceDocument(_methodBody.Syntax));
-                BoundExpression payloadSlot = _methodBodyFactory.ArrayAccess(_methodBodyFactory.InstrumentationPayloadRoot(analysisKind, modulePayloadType), ImmutableArray.Create(_methodBodyFactory.MethodDefIndex(_method)));
-                BoundStatement createPayloadCall = _methodBodyFactory.Assignment(_methodBodyFactory.Local(_methodPayload), _methodBodyFactory.Call(null, _createPayload, mvid, methodToken, fileIndex, payloadSlot, _methodBodyFactory.Literal(_dynamicAnalysisSpans.Length)));
 
-                BoundExpression payloadNullTest = _methodBodyFactory.Binary(BinaryOperatorKind.ObjectEqual, _methodBodyFactory.SpecialType(SpecialType.System_Boolean), _methodBodyFactory.Local(_methodPayload), _methodBodyFactory.Null(_payloadType));
+                BoundExpression payloadSlot =
+                    _methodBodyFactory.ArrayAccess(
+                        _methodBodyFactory.InstrumentationPayloadRoot(analysisKind, modulePayloadType),
+                        ImmutableArray.Create(_methodBodyFactory.MethodDefIndex(_method)));
+
+                BoundStatement createPayloadCall =
+                    GetCreatePayloadStatement(
+                        _dynamicAnalysisSpans,
+                        _methodBody.Syntax,
+                        _methodPayload,
+                        _createPayloadForMethodsSpanningSingleFile,
+                        _createPayloadForMethodsSpanningMultipleFiles,
+                        mvid,
+                        methodToken,
+                        payloadSlot,
+                        _methodBodyFactory,
+                        _debugDocumentProvider);
+
+                BoundExpression payloadNullTest =
+                    _methodBodyFactory.Binary(
+                        BinaryOperatorKind.ObjectEqual,
+                        _methodBodyFactory.SpecialType(SpecialType.System_Boolean),
+                        _methodBodyFactory.Local(_methodPayload),
+                        _methodBodyFactory.Null(_payloadType));
+
                 BoundStatement payloadIf = _methodBodyFactory.If(payloadNullTest, createPayloadCall);
 
                 Debug.Assert(synthesizedLocal == null);
@@ -271,7 +405,7 @@ public override BoundStatement InstrumentReturnStatement(BoundReturnStatement or
 
             return AddDynamicAnalysis(original, rewritten);
         }
-        
+
         private static bool ReturnsValueWithinExpressionBodiedConstruct(BoundReturnStatement returnStatement)
         {
             if (returnStatement.WasCompilerGenerated &&
@@ -340,12 +474,12 @@ private BoundStatement CollectDynamicAnalysis(BoundStatement original, BoundStat
             return statementFactory.StatementList(AddAnalysisPoint(SyntaxForSpan(original), statementFactory), rewritten);
         }
 
-        private Cci.DebugSourceDocument GetSourceDocument(SyntaxNode syntax)
+        private static Cci.DebugSourceDocument GetSourceDocument(DebugDocumentProvider debugDocumentProvider, SyntaxNode syntax)
         {
-            return GetSourceDocument(syntax, syntax.GetLocation().GetMappedLineSpan());
+            return GetSourceDocument(debugDocumentProvider, syntax, syntax.GetLocation().GetMappedLineSpan());
         }
 
-        private Cci.DebugSourceDocument GetSourceDocument(SyntaxNode syntax, FileLinePositionSpan span)
+        private static Cci.DebugSourceDocument GetSourceDocument(DebugDocumentProvider debugDocumentProvider, SyntaxNode syntax, FileLinePositionSpan span)
         {
             string path = span.Path;
             // If the path for the syntax node is empty, try the path for the entire syntax tree.
@@ -354,7 +488,7 @@ private Cci.DebugSourceDocument GetSourceDocument(SyntaxNode syntax, FileLinePos
                 path = syntax.SyntaxTree.FilePath;
             }
 
-            return _debugDocumentProvider.Invoke(path, basePath: "");
+            return debugDocumentProvider.Invoke(path, basePath: "");
         }
 
         private BoundStatement AddAnalysisPoint(SyntaxNode syntaxForSpan, Text.TextSpan alternateSpan, SyntheticBoundNodeFactory statementFactory)
@@ -371,10 +505,19 @@ private BoundStatement AddAnalysisPoint(SyntaxNode syntaxForSpan, FileLinePositi
         {
             // Add an entry in the spans array.
             int spansIndex = _spansBuilder.Count;
-            _spansBuilder.Add(new SourceSpan(GetSourceDocument(syntaxForSpan, span), span.StartLinePosition.Line, span.StartLinePosition.Character, span.EndLinePosition.Line, span.EndLinePosition.Character));
+            _spansBuilder.Add(new SourceSpan(
+                GetSourceDocument(_debugDocumentProvider, syntaxForSpan, span),
+                span.StartLinePosition.Line,
+                span.StartLinePosition.Character,
+                span.EndLinePosition.Line,
+                span.EndLinePosition.Character));
 
             // Generate "_payload[pointIndex] = true".
-            BoundArrayAccess payloadCell = statementFactory.ArrayAccess(statementFactory.Local(_methodPayload), statementFactory.Literal(spansIndex));
+            BoundArrayAccess payloadCell =
+                statementFactory.ArrayAccess(
+                    statementFactory.Local(_methodPayload),
+                    statementFactory.Literal(spansIndex));
+
             return statementFactory.Assignment(payloadCell, statementFactory.Literal(true));
         }
 
@@ -421,10 +564,10 @@ private static SyntaxNode SyntaxForSpan(BoundStatement statement)
 
             return syntaxForSpan;
         }
-        
-        private static MethodSymbol GetCreatePayload(CSharpCompilation compilation, SyntaxNode syntax, DiagnosticBag diagnostics)
+
+        private static MethodSymbol GetCreatePayloadOverload(CSharpCompilation compilation, WellKnownMember overload, SyntaxNode syntax, DiagnosticBag diagnostics)
         {
-            return (MethodSymbol)Binder.GetWellKnownTypeMember(compilation, WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayload, diagnostics, syntax: syntax);
+            return (MethodSymbol)Binder.GetWellKnownTypeMember(compilation, overload, diagnostics, syntax: syntax);
         }
 
         private static SyntaxNode MethodDeclarationIfAvailable(SyntaxNode body)
@@ -478,7 +621,7 @@ private static Text.TextSpan SkipAttributes(SyntaxNode syntax)
 
             return syntax.Span;
         }
-        
+
         private static Text.TextSpan SkipAttributes(SyntaxNode syntax, SyntaxList<AttributeListSyntax> attributes, SyntaxTokenList modifiers, SyntaxToken keyword, TypeSyntax type)
         {
             Text.TextSpan originalSpan = syntax.Span;
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicAnalysisResourceTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicAnalysisResourceTests.cs
index caf46a49ac240..9b05a1b5c8d19 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicAnalysisResourceTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicAnalysisResourceTests.cs
@@ -24,6 +24,11 @@ public static bool[] CreatePayload(System.Guid mvid, int methodToken, int fileIn
             return payload;
         }
 
+        public static bool[] CreatePayload(System.Guid mvid, int methodToken, int[] fileIndices, ref bool[] payload, int payloadLength)
+        {
+            return payload;
+        }
+
         public static void FlushPayload()
         {
         }
@@ -63,14 +68,14 @@ public void TestSpansPresentInResource()
         {
             var c = CreateStandardCompilation(Parse(ExampleSource + InstrumentationHelperSource, @"C:\myproject\doc1.cs"));
             var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
-       
+
             var peReader = new PEReader(peImage);
             var reader = DynamicAnalysisDataReader.TryCreateFromPE(peReader, "<DynamicAnalysisData>");
 
             VerifyDocuments(reader, reader.Documents,
-                @"'C:\myproject\doc1.cs' FF-9A-1F-F4-03-A5-A1-F7-8D-CD-00-15-67-0E-BA-F7-23-9D-3F-0F (SHA1)");
+                @"'C:\myproject\doc1.cs' 44-3F-7C-A1-EF-CA-A8-16-40-D2-09-4F-3E-52-7C-44-8D-22-C8-02 (SHA1)");
 
-            Assert.Equal(12, reader.Methods.Length);
+            Assert.Equal(13, reader.Methods.Length);
 
             string[] sourceLines = ExampleSource.Split('\n');
 
@@ -212,9 +217,9 @@ public static void Main()
             var reader = DynamicAnalysisDataReader.TryCreateFromPE(peReader, "<DynamicAnalysisData>");
 
             VerifyDocuments(reader, reader.Documents,
-                @"'C:\myproject\doc1.cs' 89-73-A7-64-40-88-BA-0A-21-33-05-5D-E7-22-9B-74-1C-6A-2C-DC (SHA1)");
+                @"'C:\myproject\doc1.cs' 6A-DC-C0-8A-16-CB-7C-A5-99-8B-2E-0C-3C-81-69-2C-B2-10-EE-F1 (SHA1)");
 
-            Assert.Equal(5, reader.Methods.Length);
+            Assert.Equal(6, reader.Methods.Length);
 
             string[] sourceLines = source.Split('\n');
 
@@ -332,9 +337,9 @@ ref int BamBam(ref int x)                       // Method 7
             var reader = DynamicAnalysisDataReader.TryCreateFromPE(peReader, "<DynamicAnalysisData>");
 
             VerifyDocuments(reader, reader.Documents,
-                @"'C:\myproject\doc1.cs' 45-00-3A-4C-F3-AC-01-6A-D2-57-35-E5-43-5E-BD-DB-98-AF-FD-41 (SHA1)");
+                @"'C:\myproject\doc1.cs' A3-08-94-55-7C-64-8D-C7-61-7A-11-0B-4B-68-2C-3B-51-C3-C4-58 (SHA1)");
 
-            Assert.Equal(14, reader.Methods.Length);
+            Assert.Equal(15, reader.Methods.Length);
 
             string[] sourceLines = source.Split('\n');
 
@@ -343,7 +348,7 @@ ref int BamBam(ref int x)                       // Method 7
                 new SpanResult(10, 8, 10, 15, "Fred()"));
 
             VerifySpans(reader, reader.Methods[1], sourceLines,
-                new SpanResult(14,4,16,5, "static void Fred()"));
+                new SpanResult(14, 4, 16, 5, "static void Fred()"));
 
             VerifySpans(reader, reader.Methods[2], sourceLines,
                 new SpanResult(18, 4, 21, 5, "static C()"),
@@ -537,7 +542,7 @@ public void Deconstruct(out int x, out int y)
     }
 }
 ";
-            var c = CreateStandardCompilation(Parse(source + InstrumentationHelperSource, @"C:\myproject\doc1.cs"), references: new[] { ValueTupleRef, SystemRuntimeFacadeRef});
+            var c = CreateStandardCompilation(Parse(source + InstrumentationHelperSource, @"C:\myproject\doc1.cs"), references: new[] { ValueTupleRef, SystemRuntimeFacadeRef });
             var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
 
             var peReader = new PEReader(peImage);
@@ -705,7 +710,7 @@ static void TestMain()                                      // Method 1
             VerifySpans(reader, reader.Methods[2], sourceLines,
                new SpanResult(15, 4, 15, 28, "static int Init() => 33"),
                new SpanResult(15, 25, 15, 27, "33"));
-            
+
             VerifySpans(reader, reader.Methods[5], sourceLines,                     // Synthesized instance constructor
                 new SpanResult(17, 13, 17, 19, "Init()"),
                 new SpanResult(18, 13, 18, 24, "Init() + 12"),
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
index eed66d111bea2..96606e7afabd8 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
@@ -26,6 +26,7 @@ public static void Main(string[] args)
     }
 }
 ";
+
             string expectedOutput = @"Flushing
 Method 1
 File 1
@@ -47,8 +48,28 @@ File 1
 True
 True
 True
+True
+True
 ";
-            string expectedCreatePayloadIL = @"{
+
+            string expectedCreatePayloadForMethodsSpanningSingleFileIL = @"{
+  // Code size       21 (0x15)
+  .maxstack  6
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  ldc.i4.1
+  IL_0003:  newarr     ""int""
+  IL_0008:  dup
+  IL_0009:  ldc.i4.0
+  IL_000a:  ldarg.2
+  IL_000b:  stelem.i4
+  IL_000c:  ldarg.3
+  IL_000d:  ldarg.s    V_4
+  IL_000f:  call       ""bool[] Microsoft.CodeAnalysis.Runtime.Instrumentation.CreatePayload(System.Guid, int, int[], ref bool[], int)""
+  IL_0014:  ret
+}";
+
+            string expectedCreatePayloadForMethodsSpanningMultipleFilesIL = @"{
   // Code size       87 (0x57)
   .maxstack  3
   IL_0000:  ldsfld     ""System.Guid Microsoft.CodeAnalysis.Runtime.Instrumentation._mvid""
@@ -59,8 +80,8 @@ .maxstack  3
   IL_000f:  newarr     ""bool[]""
   IL_0014:  stsfld     ""bool[][] Microsoft.CodeAnalysis.Runtime.Instrumentation._payloads""
   IL_0019:  ldc.i4.s   100
-  IL_001b:  newarr     ""int""
-  IL_0020:  stsfld     ""int[] Microsoft.CodeAnalysis.Runtime.Instrumentation._fileIndices""
+  IL_001b:  newarr     ""int[]""
+  IL_0020:  stsfld     ""int[][] Microsoft.CodeAnalysis.Runtime.Instrumentation._fileIndices""
   IL_0025:  ldarg.0
   IL_0026:  stsfld     ""System.Guid Microsoft.CodeAnalysis.Runtime.Instrumentation._mvid""
   IL_002b:  ldarg.3
@@ -74,10 +95,10 @@ .maxstack  3
   IL_0041:  ldarg.3
   IL_0042:  ldind.ref
   IL_0043:  stelem.ref
-  IL_0044:  ldsfld     ""int[] Microsoft.CodeAnalysis.Runtime.Instrumentation._fileIndices""
+  IL_0044:  ldsfld     ""int[][] Microsoft.CodeAnalysis.Runtime.Instrumentation._fileIndices""
   IL_0049:  ldarg.1
   IL_004a:  ldarg.2
-  IL_004b:  stelem.i4
+  IL_004b:  stelem.ref
   IL_004c:  ldarg.3
   IL_004d:  ldind.ref
   IL_004e:  ret
@@ -88,12 +109,13 @@ .maxstack  3
 }";
 
             string expectedFlushPayloadIL = @"{
-  // Code size      247 (0xf7)
+  // Code size      288 (0x120)
   .maxstack  5
   .locals init (bool[] V_0,
                 int V_1, //i
                 bool[] V_2, //payload
-                int V_3) //j
+                int V_3, //j
+                int V_4) //j
   IL_0000:  ldsfld     ""bool[][] <PrivateImplementationDetails>.PayloadRoot0""
   IL_0005:  ldtoken    ""void Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload()""
   IL_000a:  ldelem.ref
@@ -106,7 +128,7 @@ .locals init (bool[] V_0,
   IL_001e:  ldsfld     ""bool[][] <PrivateImplementationDetails>.PayloadRoot0""
   IL_0023:  ldtoken    ""void Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload()""
   IL_0028:  ldelema    ""bool[]""
-  IL_002d:  ldc.i4.s   14
+  IL_002d:  ldc.i4.s   16
   IL_002f:  call       ""bool[] Microsoft.CodeAnalysis.Runtime.Instrumentation.CreatePayload(System.Guid, int, int, ref bool[], int)""
   IL_0034:  stloc.0
   IL_0035:  ldloc.0
@@ -136,7 +158,7 @@ .locals init (bool[] V_0,
   IL_005a:  stelem.i1
   IL_005b:  ldc.i4.0
   IL_005c:  stloc.1
-  IL_005d:  br         IL_00e9
+  IL_005d:  br         IL_0112
   IL_0062:  ldloc.0
   IL_0063:  ldc.i4.6
   IL_0064:  ldc.i4.1
@@ -146,84 +168,110 @@ .locals init (bool[] V_0,
   IL_006c:  ldelem.ref
   IL_006d:  stloc.2
   IL_006e:  ldloc.0
-  IL_006f:  ldc.i4.s   13
+  IL_006f:  ldc.i4.s   15
   IL_0071:  ldc.i4.1
   IL_0072:  stelem.i1
   IL_0073:  ldloc.2
-  IL_0074:  brfalse.s  IL_00e1
-  IL_0076:  ldloc.0
-  IL_0077:  ldc.i4.7
-  IL_0078:  ldc.i4.1
-  IL_0079:  stelem.i1
-  IL_007a:  ldstr      ""Method ""
-  IL_007f:  ldloca.s   V_1
-  IL_0081:  call       ""string int.ToString()""
-  IL_0086:  call       ""string string.Concat(string, string)""
-  IL_008b:  call       ""void System.Console.WriteLine(string)""
-  IL_0090:  ldloc.0
-  IL_0091:  ldc.i4.8
-  IL_0092:  ldc.i4.1
-  IL_0093:  stelem.i1
-  IL_0094:  ldstr      ""File ""
-  IL_0099:  ldsfld     ""int[] Microsoft.CodeAnalysis.Runtime.Instrumentation._fileIndices""
-  IL_009e:  ldloc.1
-  IL_009f:  ldelema    ""int""
-  IL_00a4:  call       ""string int.ToString()""
-  IL_00a9:  call       ""string string.Concat(string, string)""
-  IL_00ae:  call       ""void System.Console.WriteLine(string)""
-  IL_00b3:  ldloc.0
-  IL_00b4:  ldc.i4.s   9
-  IL_00b6:  ldc.i4.1
-  IL_00b7:  stelem.i1
-  IL_00b8:  ldc.i4.0
-  IL_00b9:  stloc.3
-  IL_00ba:  br.s       IL_00db
-  IL_00bc:  ldloc.0
-  IL_00bd:  ldc.i4.s   11
-  IL_00bf:  ldc.i4.1
-  IL_00c0:  stelem.i1
-  IL_00c1:  ldloc.2
-  IL_00c2:  ldloc.3
-  IL_00c3:  ldelem.u1
-  IL_00c4:  call       ""void System.Console.WriteLine(bool)""
-  IL_00c9:  ldloc.0
-  IL_00ca:  ldc.i4.s   12
-  IL_00cc:  ldc.i4.1
-  IL_00cd:  stelem.i1
-  IL_00ce:  ldloc.2
-  IL_00cf:  ldloc.3
-  IL_00d0:  ldc.i4.0
-  IL_00d1:  stelem.i1
-  IL_00d2:  ldloc.0
-  IL_00d3:  ldc.i4.s   10
-  IL_00d5:  ldc.i4.1
-  IL_00d6:  stelem.i1
-  IL_00d7:  ldloc.3
-  IL_00d8:  ldc.i4.1
-  IL_00d9:  add
-  IL_00da:  stloc.3
-  IL_00db:  ldloc.3
-  IL_00dc:  ldloc.2
-  IL_00dd:  ldlen
-  IL_00de:  conv.i4
-  IL_00df:  blt.s      IL_00bc
-  IL_00e1:  ldloc.0
-  IL_00e2:  ldc.i4.5
+  IL_0074:  brfalse    IL_010a
+  IL_0079:  ldloc.0
+  IL_007a:  ldc.i4.7
+  IL_007b:  ldc.i4.1
+  IL_007c:  stelem.i1
+  IL_007d:  ldstr      ""Method ""
+  IL_0082:  ldloca.s   V_1
+  IL_0084:  call       ""string int.ToString()""
+  IL_0089:  call       ""string string.Concat(string, string)""
+  IL_008e:  call       ""void System.Console.WriteLine(string)""
+  IL_0093:  ldloc.0
+  IL_0094:  ldc.i4.8
+  IL_0095:  ldc.i4.1
+  IL_0096:  stelem.i1
+  IL_0097:  ldc.i4.0
+  IL_0098:  stloc.3
+  IL_0099:  br.s       IL_00ca
+  IL_009b:  ldloc.0
+  IL_009c:  ldc.i4.s   10
+  IL_009e:  ldc.i4.1
+  IL_009f:  stelem.i1
+  IL_00a0:  ldstr      ""File ""
+  IL_00a5:  ldsfld     ""int[][] Microsoft.CodeAnalysis.Runtime.Instrumentation._fileIndices""
+  IL_00aa:  ldloc.1
+  IL_00ab:  ldelem.ref
+  IL_00ac:  ldloc.3
+  IL_00ad:  ldelema    ""int""
+  IL_00b2:  call       ""string int.ToString()""
+  IL_00b7:  call       ""string string.Concat(string, string)""
+  IL_00bc:  call       ""void System.Console.WriteLine(string)""
+  IL_00c1:  ldloc.0
+  IL_00c2:  ldc.i4.s   9
+  IL_00c4:  ldc.i4.1
+  IL_00c5:  stelem.i1
+  IL_00c6:  ldloc.3
+  IL_00c7:  ldc.i4.1
+  IL_00c8:  add
+  IL_00c9:  stloc.3
+  IL_00ca:  ldloc.3
+  IL_00cb:  ldsfld     ""int[][] Microsoft.CodeAnalysis.Runtime.Instrumentation._fileIndices""
+  IL_00d0:  ldloc.1
+  IL_00d1:  ldelem.ref
+  IL_00d2:  ldlen
+  IL_00d3:  conv.i4
+  IL_00d4:  blt.s      IL_009b
+  IL_00d6:  ldloc.0
+  IL_00d7:  ldc.i4.s   11
+  IL_00d9:  ldc.i4.1
+  IL_00da:  stelem.i1
+  IL_00db:  ldc.i4.0
+  IL_00dc:  stloc.s    V_4
+  IL_00de:  br.s       IL_0103
+  IL_00e0:  ldloc.0
+  IL_00e1:  ldc.i4.s   13
   IL_00e3:  ldc.i4.1
   IL_00e4:  stelem.i1
-  IL_00e5:  ldloc.1
-  IL_00e6:  ldc.i4.1
-  IL_00e7:  add
-  IL_00e8:  stloc.1
-  IL_00e9:  ldloc.1
-  IL_00ea:  ldsfld     ""bool[][] Microsoft.CodeAnalysis.Runtime.Instrumentation._payloads""
-  IL_00ef:  ldlen
-  IL_00f0:  conv.i4
-  IL_00f1:  blt        IL_0062
-  IL_00f6:  ret
+  IL_00e5:  ldloc.2
+  IL_00e6:  ldloc.s    V_4
+  IL_00e8:  ldelem.u1
+  IL_00e9:  call       ""void System.Console.WriteLine(bool)""
+  IL_00ee:  ldloc.0
+  IL_00ef:  ldc.i4.s   14
+  IL_00f1:  ldc.i4.1
+  IL_00f2:  stelem.i1
+  IL_00f3:  ldloc.2
+  IL_00f4:  ldloc.s    V_4
+  IL_00f6:  ldc.i4.0
+  IL_00f7:  stelem.i1
+  IL_00f8:  ldloc.0
+  IL_00f9:  ldc.i4.s   12
+  IL_00fb:  ldc.i4.1
+  IL_00fc:  stelem.i1
+  IL_00fd:  ldloc.s    V_4
+  IL_00ff:  ldc.i4.1
+  IL_0100:  add
+  IL_0101:  stloc.s    V_4
+  IL_0103:  ldloc.s    V_4
+  IL_0105:  ldloc.2
+  IL_0106:  ldlen
+  IL_0107:  conv.i4
+  IL_0108:  blt.s      IL_00e0
+  IL_010a:  ldloc.0
+  IL_010b:  ldc.i4.5
+  IL_010c:  ldc.i4.1
+  IL_010d:  stelem.i1
+  IL_010e:  ldloc.1
+  IL_010f:  ldc.i4.1
+  IL_0110:  add
+  IL_0111:  stloc.1
+  IL_0112:  ldloc.1
+  IL_0113:  ldsfld     ""bool[][] Microsoft.CodeAnalysis.Runtime.Instrumentation._payloads""
+  IL_0118:  ldlen
+  IL_0119:  conv.i4
+  IL_011a:  blt        IL_0062
+  IL_011f:  ret
 }";
+
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
-            verifier.VerifyIL("Microsoft.CodeAnalysis.Runtime.Instrumentation.CreatePayload", expectedCreatePayloadIL);
+            verifier.VerifyIL("Microsoft.CodeAnalysis.Runtime.Instrumentation.CreatePayload(System.Guid, int, int, ref bool[], int)", expectedCreatePayloadForMethodsSpanningSingleFileIL);
+            verifier.VerifyIL("Microsoft.CodeAnalysis.Runtime.Instrumentation.CreatePayload(System.Guid, int, int[], ref bool[], int)", expectedCreatePayloadForMethodsSpanningMultipleFilesIL);
             verifier.VerifyIL("Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload", expectedFlushPayloadIL);
             verifier.VerifyDiagnostics();
         }
@@ -344,6 +392,8 @@ File 1
 True
 True
 True
+True
+True
 ";
 
             string expectedBarneyIL = @"{
@@ -509,6 +559,8 @@ File 1
 True
 True
 True
+True
+True
 ";
 
             string expectedReleaseGetValueIL = @"{
@@ -684,6 +736,8 @@ public static void Main(string[] args)                                      // M
                 .True()
                 .True()
                 .True()
+                .True()
+                .True()
                 .True();
 
             CompilationVerifier verifier = CompileAndVerify(source, expectedOutput: checker.ExpectedOutput, options: TestOptions.ReleaseExe);
@@ -793,6 +847,8 @@ File 1
 True
 True
 True
+True
+True
 ";
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput, options: TestOptions.ReleaseExe);
             verifier.VerifyDiagnostics();
@@ -884,6 +940,8 @@ void L1()
                 .True()
                 .True()
                 .True()
+                .True()
+                .True()
                 .True();
 
             CompilationVerifier verifier = CompileAndVerify(source, expectedOutput: checker.ExpectedOutput, options: TestOptions.ReleaseExe);
@@ -965,6 +1023,8 @@ File 5
 True
 True
 True
+True
+True
 ";
 
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput, options: TestOptions.ReleaseExe);
@@ -1062,6 +1122,8 @@ File 1
 True
 True
 True
+True
+True
 ";
 
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
@@ -1158,6 +1220,8 @@ File 1
 True
 True
 True
+True
+True
 ";
 
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.UnsafeDebugExe, expectedOutput: expectedOutput);
@@ -1345,6 +1409,8 @@ File 1
 True
 True
 True
+True
+True
 ";
 
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
@@ -1437,6 +1503,8 @@ File 1
 True
 True
 True
+True
+True
 ";
 
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
@@ -1512,6 +1580,8 @@ File 1
 True
 True
 True
+True
+True
 ";
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
         }
@@ -1599,6 +1669,8 @@ File 1
 True
 True
 True
+True
+True
 ";
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
         }
@@ -1673,6 +1745,8 @@ File 1
 True
 True
 True
+True
+True
 ";
 
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
@@ -1776,6 +1850,8 @@ File 1
 True
 True
 True
+True
+True
 ";
 
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
@@ -1862,6 +1938,8 @@ File 1
 True
 True
 True
+True
+True
 ";
 
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
@@ -1973,6 +2051,8 @@ File 1
 True
 True
 True
+True
+True
 ";
 
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
@@ -2057,6 +2137,8 @@ File 1
 True
 True
 True
+True
+True
 ";
 
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
@@ -2180,6 +2262,8 @@ File 1
 True
 True
 True
+True
+True
 ";
 
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
@@ -2694,6 +2778,8 @@ static void Test()
                 .True()
                 .True()
                 .True()
+                .True()
+                .True()
                 .True();
 
             var expectedOutput = @"Test
@@ -2769,6 +2855,8 @@ static void Test()
                 .True()
                 .True()
                 .True()
+                .True()
+                .True()
                 .True();
 
             var expectedOutput = @"Test
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/MissingSpecialMember.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/MissingSpecialMember.cs
index 8a63090139df7..ebafc4df68f4e 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/MissingSpecialMember.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/MissingSpecialMember.cs
@@ -858,7 +858,8 @@ public void AllWellKnownTypeMembers()
                     case WellKnownMember.System_Array__Empty:
                         // Not yet in the platform.
                         continue;
-                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayload:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles:
                         // Not always available.
                         continue;
                 }
diff --git a/src/Compilers/Core/Portable/WellKnownMember.cs b/src/Compilers/Core/Portable/WellKnownMember.cs
index 3b054a306fcbc..23c831caa5e55 100644
--- a/src/Compilers/Core/Portable/WellKnownMember.cs
+++ b/src/Compilers/Core/Portable/WellKnownMember.cs
@@ -414,7 +414,9 @@ internal enum WellKnownMember
 
         System_String__Format_IFormatProvider,
 
-        Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayload,
+        Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile,
+        Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles,
+
         System_Runtime_CompilerServices_ReferenceAssemblyAttribute__ctor,
 
         Count
diff --git a/src/Compilers/Core/Portable/WellKnownMembers.cs b/src/Compilers/Core/Portable/WellKnownMembers.cs
index 9a972169f8329..0a701b0ff4279 100644
--- a/src/Compilers/Core/Portable/WellKnownMembers.cs
+++ b/src/Compilers/Core/Portable/WellKnownMembers.cs
@@ -2867,7 +2867,7 @@ static WellKnownMembers()
                     (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_String,
                     (byte)SignatureTypeCode.SZArray, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Object,
 
-                // Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayload
+                // Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile
                 (byte)(MemberFlags.Method | MemberFlags.Static),                                                                                    // Flags
                 (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_Instrumentation - WellKnownType.ExtSentinel),  // DeclaringTypeId
                 0,                                                                                                                                  // Arity
@@ -2879,6 +2879,18 @@ static WellKnownMembers()
                     (byte)SignatureTypeCode.ByReference, (byte)SignatureTypeCode.SZArray, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Boolean,
                     (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,
 
+                // Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles
+                (byte)(MemberFlags.Method | MemberFlags.Static),                                                                                    // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_Instrumentation - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                  // Arity
+                    5,                                                                                                                              // Method Signature
+                    (byte)SignatureTypeCode.SZArray, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Boolean,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)WellKnownType.System_Guid,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,
+                    (byte)SignatureTypeCode.SZArray, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,
+                    (byte)SignatureTypeCode.ByReference, (byte)SignatureTypeCode.SZArray, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Boolean,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,
+
                 // System_Runtime_CompilerServices_ReferenceAssemblyAttribute__ctor
                 (byte)MemberFlags.Constructor,                                                                                                      // Flags
                 (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.System_Runtime_CompilerServices_ReferenceAssemblyAttribute - WellKnownType.ExtSentinel),  // DeclaringTypeId
@@ -3242,7 +3254,8 @@ static WellKnownMembers()
                 ".ctor",                                    // System_Runtime_CompilerServices_TupleElementNamesAttribute__ctorTransformNames
 
                 "Format",                                   // System_String__Format_IFormatProvider
-                "CreatePayload",                            // Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayload
+                "CreatePayload",                            // Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile
+                "CreatePayload",                            // Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles
 
                 ".ctor",                                    // System_Runtime_CompilerServices_ReferenceAssemblyAttribute__ctor
             };
diff --git a/src/Compilers/VisualBasic/Portable/Lowering/Instrumentation/DynamicAnalysisInjector.vb b/src/Compilers/VisualBasic/Portable/Lowering/Instrumentation/DynamicAnalysisInjector.vb
index d2ccabc4e894f..9e845927a4b00 100644
--- a/src/Compilers/VisualBasic/Portable/Lowering/Instrumentation/DynamicAnalysisInjector.vb
+++ b/src/Compilers/VisualBasic/Portable/Lowering/Instrumentation/DynamicAnalysisInjector.vb
@@ -1,11 +1,11 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+Imports System.Collections.Immutable
+Imports Microsoft.Cci
 Imports Microsoft.CodeAnalysis.CodeGen
+Imports Microsoft.CodeAnalysis.Collections
 Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
-Imports Roslyn.Utilities
-Imports System.Collections.Immutable
-Imports System.Diagnostics
 
 Namespace Microsoft.CodeAnalysis.VisualBasic
 
@@ -18,7 +18,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
         Private ReadOnly _method As MethodSymbol
         Private ReadOnly _methodBody As BoundStatement
-        Private ReadOnly _createPayload As MethodSymbol
+        Private ReadOnly _createPayloadForMethodsSpanningSingleFile As MethodSymbol
+        Private ReadOnly _createPayloadForMethodsSpanningMultipleFiles As MethodSymbol
         Private ReadOnly _spansBuilder As ArrayBuilder(Of SourceSpan)
         Private _dynamicAnalysisSpans As ImmutableArray(Of SourceSpan) = ImmutableArray(Of SourceSpan).Empty
         Private ReadOnly _methodEntryInstrumentation As BoundStatement
@@ -28,7 +29,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Private ReadOnly _debugDocumentProvider As DebugDocumentProvider
         Private ReadOnly _methodBodyFactory As SyntheticBoundNodeFactory
 
-        Public Shared Function TryCreate(method As MethodSymbol, methodBody As BoundStatement, methodBodyFactory As SyntheticBoundNodeFactory, diagnostics As DiagnosticBag, debugDocumentProvider As DebugDocumentProvider, previous As Instrumenter) As DynamicAnalysisInjector
+        Public Shared Function TryCreate(
+            method As MethodSymbol,
+            methodBody As BoundStatement,
+            methodBodyFactory As SyntheticBoundNodeFactory,
+            diagnostics As DiagnosticBag,
+            debugDocumentProvider As DebugDocumentProvider,
+            previous As Instrumenter) As DynamicAnalysisInjector
+
             ' Do not instrument implicitly-declared methods, except for constructors.
             ' Instrument implicit constructors in order to instrument member initializers.
             If method.IsImplicitlyDeclared AndAlso Not method.IsAnyConstructor Then
@@ -45,20 +53,38 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 Return Nothing
             End If
 
-            Dim createPayload As MethodSymbol = GetCreatePayload(methodBodyFactory.Compilation, methodBody.Syntax, diagnostics)
+            Dim createPayloadForMethodsSpanningSingleFile As MethodSymbol = GetCreatePayloadOverload(
+                methodBodyFactory.Compilation,
+                WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile,
+                methodBody.Syntax,
+                diagnostics)
+
+            Dim createPayloadForMethodsSpanningMultipleFiles As MethodSymbol = GetCreatePayloadOverload(
+                methodBodyFactory.Compilation,
+                WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles,
+                methodBody.Syntax,
+                diagnostics)
 
             ' Do not instrument any methods if CreatePayload is not present.
-            If createPayload Is Nothing Then
+            If createPayloadForMethodsSpanningSingleFile Is Nothing OrElse createPayloadForMethodsSpanningMultipleFiles Is Nothing Then
                 Return Nothing
             End If
 
             ' Do not instrument CreatePayload if it is part of the current compilation (which occurs only during testing).
             ' CreatePayload will fail at run time with an infinite recursion if it is instrumented.
-            If method.Equals(createPayload) Then
+            If method.Equals(createPayloadForMethodsSpanningSingleFile) OrElse method.Equals(createPayloadForMethodsSpanningMultipleFiles) Then
                 Return Nothing
             End If
 
-            Return New DynamicAnalysisInjector(method, methodBody, methodBodyFactory, createPayload, diagnostics, debugDocumentProvider, previous)
+            Return New DynamicAnalysisInjector(
+                method,
+                methodBody,
+                methodBodyFactory,
+                createPayloadForMethodsSpanningSingleFile,
+                createPayloadForMethodsSpanningMultipleFiles,
+                diagnostics,
+                debugDocumentProvider,
+                previous)
         End Function
 
         Private Shared Function HasValidMappedLineSpan(syntax As SyntaxNode) As Boolean
@@ -71,9 +97,19 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
 
-        Private Sub New(method As MethodSymbol, methodBody As BoundStatement, methodBodyFactory As SyntheticBoundNodeFactory, createPayload As MethodSymbol, diagnostics As DiagnosticBag, debugDocumentProvider As DebugDocumentProvider, previous As Instrumenter)
+        Private Sub New(
+            method As MethodSymbol,
+            methodBody As BoundStatement,
+            methodBodyFactory As SyntheticBoundNodeFactory,
+            createPayloadForMethodsSpanningSingleFile As MethodSymbol,
+            createPayloadForMethodsSpanningMultipleFiles As MethodSymbol,
+            diagnostics As DiagnosticBag,
+            debugDocumentProvider As DebugDocumentProvider,
+            previous As Instrumenter)
+
             MyBase.New(previous)
-            _createPayload = createPayload
+            _createPayloadForMethodsSpanningSingleFile = createPayloadForMethodsSpanningSingleFile
+            _createPayloadForMethodsSpanningMultipleFiles = createPayloadForMethodsSpanningMultipleFiles
             _method = method
             _methodBody = methodBody
             _spansBuilder = ArrayBuilder(Of SourceSpan).GetInstance()
@@ -128,6 +164,69 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return False
         End Function
 
+        Private Shared Function GetCreatePayloadStatement(
+            dynamicAnalysisSpans As ImmutableArray(Of SourceSpan),
+            methodBodySyntax As SyntaxNode,
+            methodPayload As LocalSymbol,
+            createPayloadForMethodsSpanningSingleFile As MethodSymbol,
+            createPayloadForMethodsSpanningMultipleFiles As MethodSymbol,
+            mvid As BoundExpression,
+            methodToken As BoundExpression,
+            payloadSlot As BoundExpression,
+            methodBodyFactory As SyntheticBoundNodeFactory,
+            debugDocumentProvider As DebugDocumentProvider) As BoundExpressionStatement
+
+            Dim createPayloadOverload As MethodSymbol
+            Dim fileIndexOrIndicesArgument As BoundExpression
+
+            If dynamicAnalysisSpans.IsEmpty Then
+                createPayloadOverload = createPayloadForMethodsSpanningSingleFile
+
+                ' For a compiler generated method that has no 'real' spans, we emit the index for
+                ' the document corresponding to the syntax node that is associated with its bound node.
+                Dim document = GetSourceDocument(debugDocumentProvider, methodBodySyntax)
+                fileIndexOrIndicesArgument = methodBodyFactory.SourceDocumentIndex(document)
+            Else
+                Dim documents = PooledHashSet(Of DebugSourceDocument).GetInstance()
+                Dim fileIndices = ArrayBuilder(Of BoundExpression).GetInstance()
+
+                For Each span In dynamicAnalysisSpans
+                    Dim document = span.Document
+                    If documents.Add(document) Then
+                        fileIndices.Add(methodBodyFactory.SourceDocumentIndex(document))
+                    End If
+                Next
+
+                documents.Free()
+
+                ' At this point, we should have at least one document since we have already
+                ' handled the case where method has no 'real' spans (and therefore no documents) above.
+                If fileIndices.Count = 1 Then
+                    createPayloadOverload = createPayloadForMethodsSpanningSingleFile
+                    fileIndexOrIndicesArgument = fileIndices.Single()
+                Else
+                    createPayloadOverload = createPayloadForMethodsSpanningMultipleFiles
+
+                    ' Order of elements in fileIndices should be deterministic because these
+                    ' elements were added based on order of spans in dynamicAnalysisSpans above.
+                    fileIndexOrIndicesArgument = methodBodyFactory.Array(
+                        methodBodyFactory.SpecialType(SpecialType.System_Int32), fileIndices.ToImmutable())
+                End If
+
+                fileIndices.Free()
+            End If
+
+            Return methodBodyFactory.Assignment(
+                methodBodyFactory.Local(methodPayload, isLValue:=True),
+                methodBodyFactory.Call(
+                    Nothing,
+                    createPayloadOverload,
+                    mvid,
+                    methodToken,
+                    fileIndexOrIndicesArgument,
+                    payloadSlot,
+                    methodBodyFactory.Literal(dynamicAnalysisSpans.Length)))
+        End Function
 
         Public Overrides Function CreateBlockPrologue(trueOriginal As BoundBlock, original As BoundBlock, ByRef synthesizedLocal As LocalSymbol) As BoundStatement
             Dim previousPrologue As BoundStatement = MyBase.CreateBlockPrologue(trueOriginal, original, synthesizedLocal)
@@ -137,23 +236,53 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 ' In the future there will be multiple analysis kinds.
                 Const analysisKind As Integer = 0
 
-                Dim modulePayloadType As ArrayTypeSymbol = ArrayTypeSymbol.CreateVBArray(_payloadType, ImmutableArray(Of CustomModifier).Empty, 1, _methodBodyFactory.Compilation.Assembly)
+                Dim modulePayloadType As ArrayTypeSymbol =
+                    ArrayTypeSymbol.CreateVBArray(_payloadType, ImmutableArray(Of CustomModifier).Empty, 1, _methodBodyFactory.Compilation.Assembly)
 
                 ' Synthesize the initialization of the instrumentation payload array, using concurrency-safe code
                 '
                 ' Dim payload = PID.PayloadRootField(methodIndex)
                 ' If payload Is Nothing Then
-                '     payload = Instrumentation.CreatePayload(mvid, methodIndex, fileIndex, PID.PayloadRootField(methodIndex), payloadLength)
+                '     payload = Instrumentation.CreatePayload(mvid, methodIndex, fileIndexOrIndices, PID.PayloadRootField(methodIndex), payloadLength)
                 ' End If
 
-                Dim payloadInitialization As BoundStatement = _methodBodyFactory.Assignment(_methodBodyFactory.Local(_methodPayload, isLValue:=True), _methodBodyFactory.ArrayAccess(_methodBodyFactory.InstrumentationPayloadRoot(analysisKind, modulePayloadType, isLValue:=False), isLValue:=False, indices:=ImmutableArray.Create(_methodBodyFactory.MethodDefIndex(_method))))
+                Dim payloadInitialization As BoundStatement =
+                    _methodBodyFactory.Assignment(
+                        _methodBodyFactory.Local(_methodPayload, isLValue:=True),
+                        _methodBodyFactory.ArrayAccess(
+                            _methodBodyFactory.InstrumentationPayloadRoot(analysisKind, modulePayloadType, isLValue:=False),
+                            isLValue:=False,
+                            indices:=ImmutableArray.Create(_methodBodyFactory.MethodDefIndex(_method))))
+
                 Dim mvid As BoundExpression = _methodBodyFactory.ModuleVersionId(isLValue:=False)
                 Dim methodToken As BoundExpression = _methodBodyFactory.MethodDefIndex(_method)
-                Dim fileIndex As BoundExpression = _methodBodyFactory.SourceDocumentIndex(GetSourceDocument(_methodBody.Syntax))
-                Dim payloadSlot As BoundExpression = _methodBodyFactory.ArrayAccess(_methodBodyFactory.InstrumentationPayloadRoot(analysisKind, modulePayloadType, isLValue:=False), isLValue:=True, indices:=ImmutableArray.Create(_methodBodyFactory.MethodDefIndex(_method)))
-                Dim createPayloadCall As BoundStatement = _methodBodyFactory.Assignment(_methodBodyFactory.Local(_methodPayload, isLValue:=True), _methodBodyFactory.Call(Nothing, _createPayload, mvid, methodToken, fileIndex, payloadSlot, _methodBodyFactory.Literal(_dynamicAnalysisSpans.Length)))
 
-                Dim payloadNullTest As BoundExpression = _methodBodyFactory.Binary(BinaryOperatorKind.Equals, _methodBodyFactory.SpecialType(SpecialType.System_Boolean), _methodBodyFactory.Local(_methodPayload, False), _methodBodyFactory.Null(_payloadType))
+                Dim payloadSlot As BoundExpression =
+                    _methodBodyFactory.ArrayAccess(
+                        _methodBodyFactory.InstrumentationPayloadRoot(analysisKind, modulePayloadType, isLValue:=False),
+                        isLValue:=True,
+                        indices:=ImmutableArray.Create(_methodBodyFactory.MethodDefIndex(_method)))
+
+                Dim createPayloadCall As BoundStatement =
+                    GetCreatePayloadStatement(
+                        _dynamicAnalysisSpans,
+                        _methodBody.Syntax,
+                        _methodPayload,
+                        _createPayloadForMethodsSpanningSingleFile,
+                        _createPayloadForMethodsSpanningMultipleFiles,
+                        mvid,
+                        methodToken,
+                        payloadSlot,
+                        _methodBodyFactory,
+                        _debugDocumentProvider)
+
+                Dim payloadNullTest As BoundExpression =
+                    _methodBodyFactory.Binary(
+                        BinaryOperatorKind.Equals,
+                        _methodBodyFactory.SpecialType(SpecialType.System_Boolean),
+                        _methodBodyFactory.Local(_methodPayload, False),
+                        _methodBodyFactory.Null(_payloadType))
+
                 Dim payloadIf As BoundStatement = _methodBodyFactory.If(payloadNullTest, createPayloadCall)
 
                 Debug.Assert(synthesizedLocal Is Nothing)
@@ -300,18 +429,18 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return If(rewritten IsNot Nothing, statementFactory.StatementList(analysisPoint, rewritten), analysisPoint)
         End Function
 
-        Private Function GetSourceDocument(syntax As SyntaxNode) As Cci.DebugSourceDocument
-            Return GetSourceDocument(syntax, syntax.GetLocation().GetMappedLineSpan())
+        Private Shared Function GetSourceDocument(debugDocumentProvider As DebugDocumentProvider, syntax As SyntaxNode) As Cci.DebugSourceDocument
+            Return GetSourceDocument(debugDocumentProvider, syntax, syntax.GetLocation().GetMappedLineSpan())
         End Function
 
-        Private Function GetSourceDocument(syntax As SyntaxNode, span As FileLinePositionSpan) As Cci.DebugSourceDocument
+        Private Shared Function GetSourceDocument(debugDocumentProvider As DebugDocumentProvider, syntax As SyntaxNode, span As FileLinePositionSpan) As Cci.DebugSourceDocument
             Dim path As String = span.Path
             ' If the path for the syntax node is empty, try the path for the entire syntax tree.
             If path.Length = 0 Then
                 path = syntax.SyntaxTree.FilePath
             End If
 
-            Return _debugDocumentProvider.Invoke(path, basePath:="")
+            Return debugDocumentProvider.Invoke(path, basePath:="")
         End Function
 
         Private Function AddAnalysisPoint(syntaxForSpan As SyntaxNode, alternateSpan As Text.TextSpan, statementFactory As SyntheticBoundNodeFactory) As BoundStatement
@@ -323,13 +452,22 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         End Function
 
         Private Function AddAnalysisPoint(syntaxForSpan As SyntaxNode, span As FileLinePositionSpan, statementFactory As SyntheticBoundNodeFactory) As BoundStatement
-
             ' Add an entry in the spans array.
             Dim spansIndex As Integer = _spansBuilder.Count
-            _spansBuilder.Add(New SourceSpan(GetSourceDocument(syntaxForSpan, span), span.StartLinePosition.Line, span.StartLinePosition.Character, span.EndLinePosition.Line, span.EndLinePosition.Character))
+            _spansBuilder.Add(New SourceSpan(
+                GetSourceDocument(_debugDocumentProvider, syntaxForSpan, span),
+                span.StartLinePosition.Line,
+                span.StartLinePosition.Character,
+                span.EndLinePosition.Line,
+                span.EndLinePosition.Character))
 
             ' Generate "_payload(pointIndex) = True".
-            Dim payloadCell As BoundArrayAccess = statementFactory.ArrayAccess(statementFactory.Local(_methodPayload, isLValue:=False), isLValue:=True, indices:=ImmutableArray.Create(Of BoundExpression)(statementFactory.Literal(spansIndex)))
+            Dim payloadCell As BoundArrayAccess =
+                statementFactory.ArrayAccess(
+                    statementFactory.Local(_methodPayload, isLValue:=False),
+                    isLValue:=True,
+                    indices:=ImmutableArray.Create(Of BoundExpression)(statementFactory.Literal(spansIndex)))
+
             Return statementFactory.Assignment(payloadCell, statementFactory.Literal(True))
         End Function
 
@@ -371,8 +509,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return statement.Syntax
         End Function
 
-        Private Shared Function GetCreatePayload(compilation As VisualBasicCompilation, syntax As SyntaxNode, diagnostics As DiagnosticBag) As MethodSymbol
-            Return DirectCast(Binder.GetWellKnownTypeMember(compilation, WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayload, syntax, diagnostics), MethodSymbol)
+        Private Shared Function GetCreatePayloadOverload(compilation As VisualBasicCompilation, overload As WellKnownMember, syntax As SyntaxNode, diagnostics As DiagnosticBag) As MethodSymbol
+            Return DirectCast(Binder.GetWellKnownTypeMember(compilation, overload, syntax, diagnostics), MethodSymbol)
         End Function
 
         ' If the method, property, etc. has attributes, the attributes are excluded from the span of the method definition.
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicAnalysisResourceTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicAnalysisResourceTests.vb
index 7727720592d61..56eb715c36641 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicAnalysisResourceTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicAnalysisResourceTests.vb
@@ -1,15 +1,12 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-Imports System
 Imports System.Collections.Immutable
-Imports System.Linq
 Imports System.Reflection.PortableExecutable
 Imports System.Xml.Linq
 Imports Microsoft.CodeAnalysis.Emit
 Imports Microsoft.CodeAnalysis.Test.Utilities
 Imports Microsoft.CodeAnalysis.VisualBasic.UnitTests
 Imports Roslyn.Test.Utilities
-Imports Xunit
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.DynamicAnalysis.UnitTests
 
@@ -24,6 +21,10 @@ Namespace Microsoft.CodeAnalysis.Runtime
             Return payload
         End Function
 
+        Public Shared Function CreatePayload(mvid As System.Guid, methodToken As Integer, fileIndices As Integer(), ByRef payload As Boolean(), payloadLength As Integer) As Boolean()
+            Return payload
+        End Function
+
         Public Shared Sub FlushPayload()
         End Sub
     End Class
@@ -76,9 +77,9 @@ End Class
 
             VerifyDocuments(reader, reader.Documents,
                             "'c.vb' 1A-10-00-3A-D1-71-8C-BD-53-CC-9D-9C-5D-53-5D-7F-8C-70-89-0F (SHA1)",
-                            "'a.vb' 04-2B-9F-E0-61-0E-58-A3-32-F2-82-C4-EB-B6-2F-CD-CA-42-5D-D5 (SHA1)")
+                            "'a.vb' C2-D0-74-6D-08-69-59-85-2E-64-93-75-AE-DD-55-73-C3-C1-48-3A (SHA1)")
 
-            Assert.Equal(11, reader.Methods.Length)
+            Assert.Equal(12, reader.Methods.Length)
 
             Dim sourceLines As String() = ExampleSource.ToString().Split(vbLf(0))
 
@@ -193,7 +194,7 @@ End Module
 
             VerifyDocuments(reader, reader.Documents,
                             "'c.vb' 55-FA-D1-46-BA-6F-EC-77-0E-02-1A-A6-BC-62-21-F7-E3-31-4F-2C (SHA1)",
-                            "'a.vb' 04-2B-9F-E0-61-0E-58-A3-32-F2-82-C4-EB-B6-2F-CD-CA-42-5D-D5 (SHA1)")
+                            "'a.vb' C2-D0-74-6D-08-69-59-85-2E-64-93-75-AE-DD-55-73-C3-C1-48-3A (SHA1)")
 
             Dim sourceLines As String() = testSource.ToString().Split(vbLf(0))
 
@@ -293,7 +294,7 @@ End Module
 
             VerifyDocuments(reader, reader.Documents,
                             "'c.vb' 36-B0-C2-29-F1-DC-B1-63-93-45-31-11-58-6C-5A-46-89-A1-42-34 (SHA1)",
-                            "'a.vb' 04-2B-9F-E0-61-0E-58-A3-32-F2-82-C4-EB-B6-2F-CD-CA-42-5D-D5 (SHA1)")
+                            "'a.vb' C2-D0-74-6D-08-69-59-85-2E-64-93-75-AE-DD-55-73-C3-C1-48-3A (SHA1)")
 
             Dim sourceLines As String() = testSource.ToString().Split(vbLf(0))
 
@@ -361,7 +362,7 @@ End Module
 
             VerifyDocuments(reader, reader.Documents,
                             "'c.vb' 1B-06-B9-C5-D5-D3-AD-EE-8A-D3-31-8F-48-EC-20-BE-AF-7D-2C-27 (SHA1)",
-                            "'a.vb' 04-2B-9F-E0-61-0E-58-A3-32-F2-82-C4-EB-B6-2F-CD-CA-42-5D-D5 (SHA1)")
+                            "'a.vb' C2-D0-74-6D-08-69-59-85-2E-64-93-75-AE-DD-55-73-C3-C1-48-3A (SHA1)")
 
             Dim sourceLines As String() = testSource.ToString().Split(vbLf(0))
 
@@ -455,7 +456,7 @@ End Class
 
             VerifyDocuments(reader, reader.Documents,
                             "'c.vb' 49-14-6E-73-25-48-FF-97-B3-56-26-54-65-D2-2B-00-B2-1A-FA-F5 (SHA1)",
-                            "'a.vb' 04-2B-9F-E0-61-0E-58-A3-32-F2-82-C4-EB-B6-2F-CD-CA-42-5D-D5 (SHA1)")
+                            "'a.vb' C2-D0-74-6D-08-69-59-85-2E-64-93-75-AE-DD-55-73-C3-C1-48-3A (SHA1)")
 
             Dim sourceLines As String() = testSource.ToString().Split(vbLf(0))
 
@@ -560,7 +561,7 @@ End Class
 
             VerifyDocuments(reader, reader.Documents,
                             "'c.vb' 13-52-6F-4D-3B-A7-8B-F7-A3-50-EE-1C-3B-0A-57-AB-B7-E5-33-0C (SHA1)",
-                            "'a.vb' 04-2B-9F-E0-61-0E-58-A3-32-F2-82-C4-EB-B6-2F-CD-CA-42-5D-D5 (SHA1)")
+                            "'a.vb' C2-D0-74-6D-08-69-59-85-2E-64-93-75-AE-DD-55-73-C3-C1-48-3A (SHA1)")
 
             Dim sourceLines As String() = testSource.ToString().Split(vbLf(0))
 
@@ -650,7 +651,7 @@ End Class
 
             VerifyDocuments(reader, reader.Documents,
                             "'c.vb' 7D-27-1F-B0-ED-E6-00-8D-6C-FF-13-69-26-40-2D-4B-AB-06-0D-2E (SHA1)",
-                            "'a.vb' 04-2B-9F-E0-61-0E-58-A3-32-F2-82-C4-EB-B6-2F-CD-CA-42-5D-D5 (SHA1)")
+                            "'a.vb' C2-D0-74-6D-08-69-59-85-2E-64-93-75-AE-DD-55-73-C3-C1-48-3A (SHA1)")
 
             Dim sourceLines As String() = testSource.ToString().Split(vbLf(0))
 
@@ -748,7 +749,7 @@ End Module
 
             VerifyDocuments(reader, reader.Documents,
                             "'c.vb' 71-DD-56-A9-0E-56-57-E0-2B-53-EC-DA-0E-60-47-5E-CD-D1-D9-16 (SHA1)",
-                            "'a.vb' 04-2B-9F-E0-61-0E-58-A3-32-F2-82-C4-EB-B6-2F-CD-CA-42-5D-D5 (SHA1)")
+                            "'a.vb' C2-D0-74-6D-08-69-59-85-2E-64-93-75-AE-DD-55-73-C3-C1-48-3A (SHA1)")
 
             Dim sourceLines As String() = testSource.ToString().Split(vbLf(0))
 
@@ -833,23 +834,23 @@ End Module
             Next
 
             VerifySpans(reader, methodData, expectedSpanSpellings.ToArrayAndFree())
-        End sub
+        End Sub
 
         Private Shared Sub VerifySpans(reader As DynamicAnalysisDataReader, methodData As DynamicAnalysisMethod, ParamArray expected As String())
-                AssertEx.Equal(expected, reader.GetSpans(methodData.Blob).Select(Function(s) $"({s.StartLine},{s.StartColumn})-({s.EndLine},{s.EndColumn})"))
-            End Sub
+            AssertEx.Equal(expected, reader.GetSpans(methodData.Blob).Select(Function(s) $"({s.StartLine},{s.StartColumn})-({s.EndLine},{s.EndColumn})"))
+        End Sub
 
-            Private Sub VerifyDocuments(reader As DynamicAnalysisDataReader, documents As ImmutableArray(Of DynamicAnalysisDocument), ParamArray expected As String())
-                Dim sha1 = New Guid("ff1816ec-aa5e-4d10-87F7-6F4963833460")
+        Private Sub VerifyDocuments(reader As DynamicAnalysisDataReader, documents As ImmutableArray(Of DynamicAnalysisDocument), ParamArray expected As String())
+            Dim sha1 = New Guid("ff1816ec-aa5e-4d10-87F7-6F4963833460")
 
-                Dim actual = From d In documents
-                             Let name = reader.GetDocumentName(d.Name)
-                             Let hash = If(d.Hash.IsNil, "", " " + BitConverter.ToString(reader.GetBytes(d.Hash)))
-                             Let hashAlgGuid = reader.GetGuid(d.HashAlgorithm)
-                             Let hashAlg = If(hashAlgGuid = sha1, " (SHA1)", If(hashAlgGuid = New Guid, "", " " + hashAlgGuid.ToString()))
-                             Select $"'{name}'{hash}{hashAlg}"
+            Dim actual = From d In documents
+                         Let name = reader.GetDocumentName(d.Name)
+                         Let hash = If(d.Hash.IsNil, "", " " + BitConverter.ToString(reader.GetBytes(d.Hash)))
+                         Let hashAlgGuid = reader.GetGuid(d.HashAlgorithm)
+                         Let hashAlg = If(hashAlgGuid = sha1, " (SHA1)", If(hashAlgGuid = New Guid, "", " " + hashAlgGuid.ToString()))
+                         Select $"'{name}'{hash}{hashAlg}"
 
-                AssertEx.Equal(expected, actual)
-            End Sub
-        End Class
+            AssertEx.Equal(expected, actual)
+        End Sub
+    End Class
 End Namespace
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.vb
index 89023dcc6d729..9c754240c54e4 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.vb
@@ -49,6 +49,7 @@ End Module
                 True().
                 True().
                 True().
+                True().
                 True()
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, checker.ExpectedOutput)
@@ -56,8 +57,7 @@ End Module
 
             verifier.VerifyIL(
                 "Program.TestMain",
-            <![CDATA[
-{
+            <![CDATA[{
   // Code size       57 (0x39)
   .maxstack  5
   .locals init (Boolean() V_0)
@@ -83,6 +83,7 @@ End Module
   IL_0038:  ret
 }
                 ]]>.Value)
+
             verifier.VerifyIL(
                 ".cctor",
             <![CDATA[
@@ -145,6 +146,7 @@ True
 True
 True
 True
+True
 ]]>
 
             ' Explicitly define the "_MyType" pre-processor definition so that the "My" template code is added to
@@ -233,6 +235,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -318,6 +321,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -448,6 +452,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -527,6 +532,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -710,6 +716,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -1022,6 +1029,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -1101,6 +1109,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -1188,6 +1197,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -1253,6 +1263,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -1330,14 +1341,15 @@ True
 True
 True
 True
-Method 9
+True
+Method 10
 File 1
 True
 True
-Method 14
+Method 15
 File 1
 True
-Method 15
+Method 16
 File 1
 True
 True
@@ -1345,7 +1357,7 @@ True
 True
 True
 True
-Method 16
+Method 17
 File 1
 True
 True
@@ -1420,6 +1432,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -1512,6 +1525,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -1623,6 +1637,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -1712,6 +1727,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -1844,6 +1860,7 @@ True
 True
 True
 True
+True
 ]]>
 
             Dim verifier As CompilationVerifier = CompileAndVerify(source, expectedOutput)
@@ -2443,6 +2460,7 @@ End Module
                 True().
                 True().
                 True().
+                True().
                 True()
 
             Dim expectedOutput = "Test
@@ -2518,6 +2536,7 @@ End Module
                 True().
                 True().
                 True().
+                True().
                 True()
 
             Dim expectedOutput = "Test
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/WellKnownTypeValidationTests.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/WellKnownTypeValidationTests.vb
index 15a93f41010b8..48871d5b26897 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/WellKnownTypeValidationTests.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/WellKnownTypeValidationTests.vb
@@ -580,7 +580,8 @@ End Namespace
                     Case WellKnownMember.System_Array__Empty
                         ' Not available yet, but will be in upcoming release.
                         Continue For
-                    Case WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayload
+                    Case WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles
                         ' Not always available.
                         Continue For
                 End Select
@@ -660,7 +661,8 @@ End Namespace
                     Case WellKnownMember.System_Array__Empty
                         ' Not available yet, but will be in upcoming release.
                         Continue For
-                    Case WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayload
+                    Case WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles
                         ' Not always available.
                         Continue For
                 End Select
diff --git a/src/Test/Utilities/Desktop/InstrumentationChecker.cs b/src/Test/Utilities/Desktop/InstrumentationChecker.cs
index 02ae83ffa32ec..78853542c670f 100755
--- a/src/Test/Utilities/Desktop/InstrumentationChecker.cs
+++ b/src/Test/Utilities/Desktop/InstrumentationChecker.cs
@@ -82,22 +82,22 @@ namespace Microsoft.CodeAnalysis.Runtime
     public static class Instrumentation
     {
         private static bool[][] _payloads;
-        private static int[] _fileIndices;
+        private static int[][] _fileIndices;
         private static System.Guid _mvid;
 
-        public static bool[] CreatePayload(System.Guid mvid, int methodIndex, int fileIndex, ref bool[] payload, int payloadLength)
+        public static bool[] CreatePayload(System.Guid mvid, int methodIndex, int[] fileIndices, ref bool[] payload, int payloadLength)
         {
             if (_mvid != mvid)
             {
                 _payloads = new bool[100][];
-                _fileIndices = new int[100];
+                _fileIndices = new int[100][];
                 _mvid = mvid;
             }
 
             if (System.Threading.Interlocked.CompareExchange(ref payload, new bool[payloadLength], null) == null)
             {
                 _payloads[methodIndex] = payload;
-                _fileIndices[methodIndex] = fileIndex;
+                _fileIndices[methodIndex] = fileIndices;
                 return payload;
             }
 
@@ -117,7 +117,10 @@ public static void FlushPayload()
                 if (payload != null)
                 {
                     Console.WriteLine(""Method "" + i.ToString());
-                    Console.WriteLine(""File "" + _fileIndices[i].ToString());
+                    for (int j = 0; j < _fileIndices[i].Length; j++)
+                    {
+                        Console.WriteLine(""File "" + _fileIndices[i][j].ToString());
+                    }
                     for (int j = 0; j < payload.Length; j++)
                     {
                         Console.WriteLine(payload[j]);
@@ -126,6 +129,11 @@ public static void FlushPayload()
                 }
             }
         }
+
+        public static bool[] CreatePayload(System.Guid mvid, int methodIndex, int fileIndex, ref bool[] payload, int payloadLength)
+        {
+            return CreatePayload(mvid, methodIndex, new[] { fileIndex }, ref payload, payloadLength);
+        }
     }
 }
 ";
@@ -210,13 +218,13 @@ Namespace Microsoft.CodeAnalysis.Runtime
     Public Class Instrumentation
 
         Private Shared _payloads As Boolean()()
-        Private Shared _fileIndices As Integer()
+        Private Shared _fileIndices As Integer()()
         Private Shared _mvid As System.Guid
 
-        Public Shared Function CreatePayload(mvid As System.Guid, methodIndex As Integer, fileIndex As Integer, ByRef payload As Boolean(), payloadLength As Integer) As Boolean()
+        Public Shared Function CreatePayload(mvid As System.Guid, methodIndex As Integer, fileIndices As Integer(), ByRef payload As Boolean(), payloadLength As Integer) As Boolean()
             If _mvid <> mvid Then
                 _payloads = New Boolean(100)() {}
-                _fileIndices = New Integer(100) {}
+                _fileIndices = New Integer(100)() {}
                 _mvid = mvid
             End If
 
@@ -225,7 +233,7 @@ If _payloads(methodIndex) IsNot Nothing Then
                     Throw New System.ArgumentException(""Overwriting existing payload array."")
                 End If
                 _payloads(methodIndex) = payload
-                _fileIndices(methodIndex) = fileIndex
+                _fileIndices(methodIndex) = fileIndices
                 Return payload
             End If
 
@@ -241,7 +249,9 @@ End If
                 Dim payload As Boolean() = _payloads(i)
                 if payload IsNot Nothing
                     System.Console.WriteLine(""Method "" & i.ToString())
-                    System.Console.WriteLine(""File "" & _fileIndices(i).ToString())
+                    For j As Integer = 0 To _fileIndices(i).Length - 1
+                        System.Console.WriteLine(""File "" & _fileIndices(i)(j).ToString())
+                    Next
                     For j As Integer = 0 To payload.Length - 1
                         System.Console.WriteLine(payload(j))
                         payload(j) = False
@@ -249,6 +259,10 @@ Dim payload As Boolean() = _payloads(i)
                 End If
             Next
         End Sub
+
+        Public Shared Function CreatePayload(mvid As System.Guid, methodIndex As Integer, fileIndex As Integer, ByRef payload As Boolean(), payloadLength As Integer) As Boolean()
+            Return CreatePayload(mvid, methodIndex, { fileIndex }, payload, payloadLength)
+        End Function
     End Class
 End Namespace
 ";

From 24e7bb61c212e7da8589eb68d8ef90e362c76a55 Mon Sep 17 00:00:00 2001
From: Shyam N <gnamboo@microsoft.com>
Date: Mon, 8 May 2017 21:13:59 -0700
Subject: [PATCH 144/284] Add C# tests for instrumentation of methods with
 spans in multiple files.

---
 .../DynamicInstrumentationTests.cs            | 338 ++++++++++++++++++
 1 file changed, 338 insertions(+)

diff --git a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
index 96606e7afabd8..a21dda5488649 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
@@ -2872,6 +2872,330 @@ static void Test()
             verifier.VerifyDiagnostics();
         }
 
+        [Fact]
+        public void TestSynthesizedConstructorWithSpansInMultipleFilesCoverage()
+        {
+            var source1 = @"
+using System;
+
+public partial class Class1<T>
+{
+    private int x = 1;
+}
+
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        Test();
+        Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();
+    }
+
+    static void Test()
+    {
+        Console.WriteLine(""Test"");
+        var c = new Class1<int>();
+        c.Method1(1);
+    }
+}
+" + InstrumentationHelperSource;
+
+            var source2 = @"
+public partial class Class1<T>
+{
+    private int y = 2;
+}
+
+public partial class Class1<T>
+{
+    private int z = 3;
+}";
+
+            var source3 = @"
+using System;
+
+public partial class Class1<T>
+{
+    private Action<int> a = i =>
+        {
+            Console.WriteLine(i);
+        };
+
+    public void Method1(int i)
+    {
+        a(i);
+        Console.WriteLine(x);
+        Console.WriteLine(y);
+        Console.WriteLine(z);
+    }
+}";
+
+            var sources = new[] {
+                (Name: "b.cs", Content: source1),
+                (Name: "c.cs", Content: source2),
+                (Name: "a.cs", Content: source3)
+            };
+
+            var expectedOutput = @"Test
+1
+1
+2
+3
+Flushing
+Method 1
+File 1
+True
+True
+True
+True
+True
+Method 2
+File 1
+File 2
+File 3
+True
+True
+True
+True
+True
+Method 3
+File 2
+True
+True
+True
+Method 4
+File 2
+True
+True
+True
+True
+Method 7
+File 2
+True
+True
+False
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+";
+
+            var verifier = CompileAndVerify(sources, expectedOutput, options: TestOptions.ReleaseExe);
+            verifier.VerifyDiagnostics();
+
+            verifier = CompileAndVerify(sources, expectedOutput, options: TestOptions.DebugExe);
+            verifier.VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void TestSynthesizedStaticConstructorWithSpansInMultipleFilesCoverage()
+        {
+            var source1 = @"
+using System;
+
+public partial class Class1<T>
+{
+    private static int x = 1;
+}
+
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        Test();
+        Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();
+    }
+
+    static void Test()
+    {
+        Console.WriteLine(""Test"");
+        var c = new Class1<int>();
+        Class1<int>.Method1(1);
+    }
+}
+" + InstrumentationHelperSource;
+
+            var source2 = @"
+public partial class Class1<T>
+{
+    private static int y = 2;
+}
+
+public partial class Class1<T>
+{
+    private static int z = 3;
+}";
+
+            var source3 = @"
+using System;
+
+public partial class Class1<T>
+{
+    private static Action<int> a = i =>
+        {
+            Console.WriteLine(i);
+        };
+
+    public static void Method1(int i)
+    {
+        a(i);
+        Console.WriteLine(x);
+        Console.WriteLine(y);
+        Console.WriteLine(z);
+    }
+}";
+
+            var sources = new[] {
+                (Name: "b.cs", Content: source1),
+                (Name: "c.cs", Content: source2),
+                (Name: "a.cs", Content: source3)
+            };
+
+            var expectedOutput = @"Test
+1
+1
+2
+3
+Flushing
+Method 1
+File 1
+True
+True
+True
+True
+True
+Method 2
+File 2
+Method 3
+File 1
+File 2
+File 3
+True
+True
+True
+True
+True
+Method 4
+File 2
+True
+True
+True
+Method 5
+File 2
+True
+True
+True
+True
+Method 8
+File 2
+True
+True
+False
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+";
+
+            var verifier = CompileAndVerify(sources, expectedOutput, options: TestOptions.ReleaseExe);
+            verifier.VerifyDiagnostics();
+
+            verifier = CompileAndVerify(sources, expectedOutput, options: TestOptions.DebugExe);
+            verifier.VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void TestLineDirectiveCoverage()
+        {
+            var source = @"
+using System;
+
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        Test();
+        Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();
+    }
+
+    static void Test()
+    {
+#line 300 ""File2.cs""
+        Console.WriteLine(""Start"");
+#line hidden
+        Console.WriteLine(""Hidden"");
+#line default
+        Console.WriteLine(""Visible"");
+#line 400 ""File3.cs""
+        Console.WriteLine(""End"");
+    }
+}
+" + InstrumentationHelperSource;
+
+            var expectedOutput = @"Start
+Hidden
+Visible
+End
+Flushing
+Method 1
+File 1
+True
+True
+True
+Method 2
+File 1
+File 2
+File 3
+True
+True
+True
+True
+True
+Method 5
+File 3
+True
+True
+False
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+";
+
+            var verifier = CompileAndVerify(source, expectedOutput, options: TestOptions.ReleaseExe);
+            verifier.VerifyDiagnostics();
+
+            verifier = CompileAndVerify(source, expectedOutput, options: TestOptions.DebugExe);
+            verifier.VerifyDiagnostics();
+        }
+
         private static void AssertNotInstrumented(CompilationVerifier verifier, string qualifiedMethodName)
             => AssertInstrumented(verifier, qualifiedMethodName, expected: false);
 
@@ -2891,6 +3215,20 @@ private CompilationVerifier CompileAndVerify(string source, string expectedOutpu
             return base.CompileAndVerify(source, expectedOutput: expectedOutput, additionalRefs: s_refs, options: (options ?? TestOptions.ReleaseExe).WithDeterministic(true), emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
         }
 
+        private CompilationVerifier CompileAndVerify((string Path, string Content)[] sources, string expectedOutput = null, CSharpCompilationOptions options = null)
+        {
+            var trees = ArrayBuilder<SyntaxTree>.GetInstance();
+            foreach (var source in sources)
+            {
+                // The trees must be assigned unique file names in order for instrumentation to work correctly.
+                trees.Add(Parse(source.Content, filename: source.Path));
+            }
+
+            var compilation = CreateStandardCompilation(trees, s_refs, (options ?? TestOptions.ReleaseExe).WithDeterministic(true));
+            trees.Free();
+            return base.CompileAndVerify(compilation, expectedOutput: expectedOutput, emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
+        }
+
         private static readonly MetadataReference[] s_refs = new[] { MscorlibRef_v4_0_30316_17626, SystemRef_v4_0_30319_17929, SystemCoreRef_v4_0_30319_17929, ValueTupleRef, SystemRuntimeFacadeRef };
     }
 }

From 1fccde6304fb6bc5b3e6add6dc301332b6564972 Mon Sep 17 00:00:00 2001
From: Shyam N <gnamboo@microsoft.com>
Date: Mon, 8 May 2017 23:47:41 -0700
Subject: [PATCH 145/284] Add VB tests for instrumentation of methods with
 spans in multiple files.

---
 .../DynamicInstrumentationTests.vb            | 238 ++++++++++++++++++
 1 file changed, 238 insertions(+)

diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.vb
index 9c754240c54e4..2ec7eb93febab 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.vb
@@ -2552,6 +2552,244 @@ Method2: x = 1
             verifier.VerifyDiagnostics()
         End Sub
 
+        <Fact>
+        Public Sub TestSynthesizedConstructorWithSpansInMultipleFilesCoverage()
+            Dim source1 = <file name="aa.vb">
+                              <![CDATA[
+Imports System
+
+Partial Class Class1
+    Dim a As Action(Of Integer) =
+            Sub(i As Integer)
+                Console.WriteLine(i)
+            End Sub
+End Class
+
+Module Program
+    Public Sub Main()
+        Test()
+        Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload()
+    End Sub
+
+    Sub Test()
+        Console.WriteLine("Test")
+        Dim c = new Class1()
+        c.Method1(1)
+    End Sub
+End Module
+]]>
+                          </file>
+
+            Dim source2 = <file name="bb.vb">
+                              <![CDATA[
+Imports System
+
+Partial Class Class1
+    Dim x As Integer = 1
+
+    Sub Method1(i As Integer)
+        a(i)
+        Console.WriteLine(x)
+        Console.WriteLine(y)
+        Console.WriteLine(z)
+    End Sub
+End Class
+]]>
+                          </file>
+
+            Dim source3 = <file name="cc.vb">
+                              <![CDATA[
+Partial Class Class1
+    Dim y As Integer = 2
+    Dim z As Integer = 3
+End Class
+]]>
+                          </file>
+
+            Dim source = <compilation>
+                             <%= source1 %>
+                             <%= source2 %>
+                             <%= source3 %>
+                             <%= InstrumentationHelperSource %>
+                         </compilation>
+
+            Dim expectedOutput = <![CDATA[Test
+1
+1
+2
+3
+Flushing
+Method 1
+File 1
+File 2
+File 3
+True
+True
+True
+True
+True
+Method 2
+File 2
+True
+True
+True
+True
+True
+Method 3
+File 1
+True
+True
+True
+Method 4
+File 1
+True
+True
+True
+True
+Method 7
+File 4
+True
+True
+False
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+]]>
+
+            Dim verifier = CompileAndVerify(source, expectedOutput, options:=TestOptions.ReleaseExe)
+            verifier.VerifyDiagnostics()
+
+            verifier = CompileAndVerify(source, expectedOutput, options:=TestOptions.DebugExe)
+            verifier.VerifyDiagnostics()
+        End Sub
+
+        <Fact>
+        Public Sub TestSynthesizedStaticConstructorWithSpansInMultipleFilesCoverage()
+            Dim source1 = <file name="aa.vb">
+                              <![CDATA[
+Imports System
+
+Partial Class Class1
+    Shared Dim a As Action(Of Integer) =
+            Sub(i As Integer)
+                Console.WriteLine(i)
+            End Sub
+End Class
+
+Module Program
+    Public Sub Main()
+        Test()
+        Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload()
+    End Sub
+
+    Sub Test()
+        Console.WriteLine("Test")
+        Dim c = new Class1()
+        Class1.Method1(1)
+    End Sub
+End Module
+]]>
+                          </file>
+
+            Dim source2 = <file name="bb.vb">
+                              <![CDATA[
+Imports System
+
+Partial Class Class1
+    Shared Dim x As Integer = 1
+
+    Shared Sub Method1(i As Integer)
+        a(i)
+        Console.WriteLine(x)
+        Console.WriteLine(y)
+        Console.WriteLine(z)
+    End Sub
+End Class
+]]>
+                          </file>
+
+            Dim source3 = <file name="cc.vb">
+                              <![CDATA[
+Partial Class Class1
+    Shared Dim y As Integer = 2
+    Shared Dim z As Integer = 3
+End Class
+]]>
+                          </file>
+
+            Dim source = <compilation>
+                             <%= source1 %>
+                             <%= source2 %>
+                             <%= source3 %>
+                             <%= InstrumentationHelperSource %>
+                         </compilation>
+
+            Dim expectedOutput = <![CDATA[Test
+1
+1
+2
+3
+Flushing
+Method 1
+File 1
+File 2
+File 3
+True
+True
+True
+True
+True
+Method 2
+File 1
+Method 3
+File 2
+True
+True
+True
+True
+True
+Method 4
+File 1
+True
+True
+True
+Method 5
+File 1
+True
+True
+True
+True
+Method 8
+File 4
+True
+True
+False
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+]]>
+
+            Dim verifier = CompileAndVerify(source, expectedOutput, options:=TestOptions.ReleaseExe)
+            verifier.VerifyDiagnostics()
+
+            verifier = CompileAndVerify(source, expectedOutput, options:=TestOptions.DebugExe)
+            verifier.VerifyDiagnostics()
+        End Sub
+
         Private Shared Sub AssertNotInstrumented(verifier As CompilationVerifier, qualifiedMethodName As String)
             AssertInstrumented(verifier, qualifiedMethodName, expected:=False)
         End Sub

From 039cdb496d3f71351b18e72414ff93030105af50 Mon Sep 17 00:00:00 2001
From: Heejae Chang <hechang@microsoft.com>
Date: Fri, 12 May 2017 13:32:31 -0700
Subject: [PATCH 146/284] fixed crash on TS due to missing designer attribute
 service on OOP

---
 .../DesignerAttributeIncrementalAnalyzer.cs                | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/VisualStudio/Core/Def/Implementation/DesignerAttribute/DesignerAttributeIncrementalAnalyzer.cs b/src/VisualStudio/Core/Def/Implementation/DesignerAttribute/DesignerAttributeIncrementalAnalyzer.cs
index 43ee00a0a7c89..11897a6425c13 100644
--- a/src/VisualStudio/Core/Def/Implementation/DesignerAttribute/DesignerAttributeIncrementalAnalyzer.cs
+++ b/src/VisualStudio/Core/Def/Implementation/DesignerAttribute/DesignerAttributeIncrementalAnalyzer.cs
@@ -90,6 +90,13 @@ public async Task AnalyzeProjectAsync(Project project, bool semanticsChanged, In
                 return;
             }
 
+            var service = project.LanguageServices.GetService<IDesignerAttributeService>();
+            if (service == null)
+            {
+                // project doesn't support designer attribute service.
+                return;
+            }
+
             // Try to compute this data in the remote process.  If that fails, then compute
             // the results in the local process.
             var pathToResult = await TryAnalyzeProjectInRemoteProcessAsync(project, cancellationToken).ConfigureAwait(false);

From 9c9e1830c5a3e0a55b98bfa013ee56cce13bb208 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Fri, 12 May 2017 13:39:29 -0700
Subject: [PATCH 147/284] Add CommonWithMetadataImportOptions

---
 src/Compilers/CSharp/Portable/CSharpCompilationOptions.cs   | 5 ++++-
 .../Core/Portable/Compilation/CompilationOptions.cs         | 3 +++
 .../VisualBasic/Portable/VisualBasicCompilationOptions.vb   | 6 +++++-
 3 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/CSharpCompilationOptions.cs b/src/Compilers/CSharp/Portable/CSharpCompilationOptions.cs
index 7cfe19323188a..1e3dc0c3c4284 100644
--- a/src/Compilers/CSharp/Portable/CSharpCompilationOptions.cs
+++ b/src/Compilers/CSharp/Portable/CSharpCompilationOptions.cs
@@ -422,7 +422,7 @@ internal CSharpCompilationOptions WithDebugPlusMode(bool debugPlusMode)
             return new CSharpCompilationOptions(this) { DebugPlusMode_internal_protected_set = debugPlusMode };
         }
 
-        internal CSharpCompilationOptions WithMetadataImportOptions(MetadataImportOptions value)
+        internal new CSharpCompilationOptions WithMetadataImportOptions(MetadataImportOptions value)
         {
             if (value == this.MetadataImportOptions)
             {
@@ -520,6 +520,9 @@ protected override CompilationOptions CommonWithMetadataReferenceResolver(Metada
         protected override CompilationOptions CommonWithStrongNameProvider(StrongNameProvider provider) =>
             WithStrongNameProvider(provider);
 
+        internal override CompilationOptions CommonWithMetadataImportOptions(MetadataImportOptions value) =>
+            WithMetadataImportOptions(value);
+
         [Obsolete]
         protected override CompilationOptions CommonWithFeatures(ImmutableArray<string> features)
         {
diff --git a/src/Compilers/Core/Portable/Compilation/CompilationOptions.cs b/src/Compilers/Core/Portable/Compilation/CompilationOptions.cs
index 95ac5f0bfcb15..7dd1ea1139f34 100644
--- a/src/Compilers/Core/Portable/Compilation/CompilationOptions.cs
+++ b/src/Compilers/Core/Portable/Compilation/CompilationOptions.cs
@@ -502,6 +502,8 @@ public CompilationOptions WithOverflowChecks(bool checkOverflow)
             return CommonWithCheckOverflow(checkOverflow);
         }
 
+        internal CompilationOptions WithMetadataImportOptions(MetadataImportOptions value) => CommonWithMetadataImportOptions(value);
+
         protected abstract CompilationOptions CommonWithConcurrentBuild(bool concurrent);
         protected abstract CompilationOptions CommonWithDeterministic(bool deterministic);
         protected abstract CompilationOptions CommonWithOutputKind(OutputKind kind);
@@ -525,6 +527,7 @@ public CompilationOptions WithOverflowChecks(bool checkOverflow)
         protected abstract CompilationOptions CommonWithCryptoPublicKey(ImmutableArray<byte> cryptoPublicKey);
         protected abstract CompilationOptions CommonWithDelaySign(bool? delaySign);
         protected abstract CompilationOptions CommonWithCheckOverflow(bool checkOverflow);
+        internal abstract CompilationOptions CommonWithMetadataImportOptions(MetadataImportOptions value);
 
         [Obsolete]
         protected abstract CompilationOptions CommonWithFeatures(ImmutableArray<string> features);
diff --git a/src/Compilers/VisualBasic/Portable/VisualBasicCompilationOptions.vb b/src/Compilers/VisualBasic/Portable/VisualBasicCompilationOptions.vb
index fbd7961992718..38c479b929a5e 100644
--- a/src/Compilers/VisualBasic/Portable/VisualBasicCompilationOptions.vb
+++ b/src/Compilers/VisualBasic/Portable/VisualBasicCompilationOptions.vb
@@ -738,6 +738,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return Me.WithReportSuppressedDiagnostics(reportSuppressedDiagnostics)
         End Function
 
+        Friend Overrides Function CommonWithMetadataImportOptions(value As MetadataImportOptions) As CompilationOptions
+            Return WithMetadataImportOptions(value)
+        End Function
+
         <Obsolete>
         Protected Overrides Function CommonWithFeatures(features As ImmutableArray(Of String)) As CompilationOptions
             Throw New NotImplementedException()
@@ -807,7 +811,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return New VisualBasicCompilationOptions(Me) With {.OptimizationLevel = value}
         End Function
 
-        Friend Function WithMetadataImportOptions(value As MetadataImportOptions) As VisualBasicCompilationOptions
+        Friend Shadows Function WithMetadataImportOptions(value As MetadataImportOptions) As VisualBasicCompilationOptions
             If value = Me.MetadataImportOptions Then
                 Return Me
             End If

From 52bbfde6011cda1ece8a51420fdfacf00844253a Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Fri, 12 May 2017 13:55:33 -0700
Subject: [PATCH 148/284] Delete SymUnmanagedReaderExtensions.cs

---
 .../Test/ExpressionCompiler/LocalsTests.cs    |   2 +-
 .../ExpressionCompiler.csproj                 |   3 -
 .../PDB/MethodDebugInfo.Native.cs             |  43 ++++++-
 .../ExpressionCompiler/PDB/PdbHelpers.cs      |  17 ++-
 .../ExpressionCompiler/MockSymUnmanaged.cs    |  35 +++---
 .../NotImplementedSymUnmanaged.cs             |  46 ++++----
 .../Test/ExpressionCompiler/LocalsTests.vb    |   2 +-
 .../Pdb/CustomDebugInfoUtilities.cs           |   2 +-
 src/Test/PdbUtilities/PdbUtilities.csproj     |   1 -
 .../Shared/SymUnmanagedReaderExtensions.cs    | 110 ------------------
 src/Test/Utilities/Portable/FX/HResult.cs     |  12 ++
 .../Utilities/Portable/TestUtilities.csproj   |   3 +-
 .../VsENCRebuildableProjectImpl.cs            |   8 +-
 .../Core/Def/ServicesVisualStudio.csproj      |   5 -
 14 files changed, 119 insertions(+), 170 deletions(-)
 delete mode 100644 src/Test/PdbUtilities/Shared/SymUnmanagedReaderExtensions.cs
 create mode 100644 src/Test/Utilities/Portable/FX/HResult.cs

diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs
index eeb555bc02e1f..cc6469a7d005c 100644
--- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs
+++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs
@@ -3729,7 +3729,7 @@ static void Main()
                     (int bufferLength, out int count, byte[] name) =>
                     {
                         count = 0;
-                        return DiaSymReader.SymUnmanagedReaderExtensions.E_NOTIMPL;
+                        return HResult.E_NOTIMPL;
                     });
                 var debugInfo = new MethodDebugInfoBytes.Builder(constants: new[] { badConst }).Build();
                 var locals = ArrayBuilder<LocalAndMethod>.GetInstance();
diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/ExpressionCompiler.csproj b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/ExpressionCompiler.csproj
index ff21a44276856..18fdcbdd0786d 100644
--- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/ExpressionCompiler.csproj
+++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/ExpressionCompiler.csproj
@@ -19,9 +19,6 @@
     <Compile Include="..\..\..\..\Test\PdbUtilities\Shared\DateTimeUtilities.cs">
       <Link>Shared\DateTimeUtilities.cs</Link>
     </Compile>
-    <Compile Include="..\..\..\..\Test\PdbUtilities\Shared\SymUnmanagedReaderExtensions.cs">
-      <Link>Shared\SymUnmanagedReaderExtensions.cs</Link>
-    </Compile>
     <Compile Include="AssemblyReaders.cs" />
     <Compile Include="AssemblyReference.cs" />
     <Compile Include="CustomTypeInfo.cs" />
diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/PDB/MethodDebugInfo.Native.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/PDB/MethodDebugInfo.Native.cs
index 4817775c42981..469e1bc1a1f18 100644
--- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/PDB/MethodDebugInfo.Native.cs
+++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/PDB/MethodDebugInfo.Native.cs
@@ -6,8 +6,9 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Reflection.Metadata;
-using Microsoft.CodeAnalysis.Debugging;
+using System.Runtime.InteropServices;
 using Microsoft.CodeAnalysis.Collections;
+using Microsoft.CodeAnalysis.Debugging;
 using Microsoft.DiaSymReader;
 using Roslyn.Utilities;
 
@@ -48,6 +49,11 @@ public override int GetHashCode()
             }
         }
 
+        internal const int S_OK = 0x0;
+        internal const int E_FAIL = unchecked((int)0x80004005);
+        internal const int E_NOTIMPL = unchecked((int)0x80004001);
+        private static readonly IntPtr s_ignoreIErrorInfo = new IntPtr(-1);
+
         public unsafe static MethodDebugInfo<TTypeSymbol, TLocalSymbol> ReadMethodDebugInfo(
             ISymUnmanagedReader3 symReader,
             EESymbolProvider<TTypeSymbol, TLocalSymbol> symbolProviderOpt, // TODO: only null in DTEE case where we looking for default namesapace
@@ -65,9 +71,9 @@ public unsafe static MethodDebugInfo<TTypeSymbol, TLocalSymbol> ReadMethodDebugI
             if (symReader is ISymUnmanagedReader5 symReader5)
             {
                 int hr = symReader5.GetPortableDebugMetadataByVersion(methodVersion, out byte* metadata, out int size);
-                SymUnmanagedReaderExtensions.ThrowExceptionForHR(hr);
+                ThrowExceptionForHR(hr);
 
-                if (hr == 0)
+                if (hr == S_OK)
                 {
                     var mdReader = new MetadataReader(metadata, size);
                     try
@@ -133,7 +139,7 @@ public unsafe static MethodDebugInfo<TTypeSymbol, TLocalSymbol> ReadMethodDebugI
                 ImmutableDictionary<int, ImmutableArray<string>> tupleLocalMap = null;
                 ImmutableDictionary<LocalNameAndScope, ImmutableArray<string>> tupleLocalConstantMap = null;
 
-                byte[] customDebugInfo = symReader.GetCustomDebugInfoBytes(methodToken, methodVersion);
+                byte[] customDebugInfo = GetCustomDebugInfoBytes(symReader, methodToken, methodVersion);
                 if (customDebugInfo != null)
                 {
                     if (!isVisualBasicMethod)
@@ -189,6 +195,33 @@ public unsafe static MethodDebugInfo<TTypeSymbol, TLocalSymbol> ReadMethodDebugI
             }
         }
 
+        private static void ThrowExceptionForHR(int hr)
+        {
+            // E_FAIL indicates "no info".
+            // E_NOTIMPL indicates a lack of ISymUnmanagedReader support (in a particular implementation).
+            if (hr < 0 && hr != E_FAIL && hr != E_NOTIMPL)
+            {
+                Marshal.ThrowExceptionForHR(hr, s_ignoreIErrorInfo);
+            }
+        }
+
+        /// <summary>
+        /// Get the blob of binary custom debug info for a given method.
+        /// </summary>
+        private static byte[] GetCustomDebugInfoBytes(ISymUnmanagedReader3 reader, int methodToken, int methodVersion)
+        {
+            try
+            {
+                return reader.GetCustomDebugInfo(methodToken, methodVersion);
+            }
+            catch (ArgumentOutOfRangeException)
+            {
+                // Sometimes the debugger returns the HRESULT for ArgumentOutOfRangeException, rather than E_FAIL,
+                // for methods without custom debug info (https://github.com/dotnet/roslyn/issues/4138).
+                return null;
+            }
+        }
+
         /// <summary>
         /// Get the (unprocessed) import strings for a given method.
         /// </summary>
@@ -255,7 +288,7 @@ private static void ReadCSharpNativeImportsInfo(
             var importStringGroups = CustomDebugInfoReader.GetCSharpGroupedImportStrings(
                 methodToken,
                 KeyValuePair.Create(reader, methodVersion),
-                getMethodCustomDebugInfo: (token, arg) => arg.Key.GetCustomDebugInfoBytes(token, arg.Value),
+                getMethodCustomDebugInfo: (token, arg) => GetCustomDebugInfoBytes(arg.Key, token, arg.Value),
                 getMethodImportStrings: (token, arg) => GetImportStrings(arg.Key, token, arg.Value),
                 externAliasStrings: out externAliasStrings);
 
diff --git a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/PDB/PdbHelpers.cs b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/PDB/PdbHelpers.cs
index 74e5de451cfd8..106b86264339f 100644
--- a/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/PDB/PdbHelpers.cs
+++ b/src/ExpressionEvaluator/Core/Source/ExpressionCompiler/PDB/PdbHelpers.cs
@@ -42,7 +42,7 @@ private static void GetAllScopes(
             {
                 var scope = stack.Pop();
                 allScopes.Add(scope);
-                if (offset >= 0 && scope.IsInScope(offset, isScopeEndInclusive))
+                if (offset >= 0 && IsInScope(scope, offset, isScopeEndInclusive))
                 {
                     containingScopes.Add(scope);
                 }
@@ -56,6 +56,21 @@ private static void GetAllScopes(
             stack.Free();
         }
 
+        private static bool IsInScope(ISymUnmanagedScope scope, int offset, bool isEndInclusive)
+        {
+            int startOffset = scope.GetStartOffset();
+            if (offset < startOffset)
+            {
+                return false;
+            }
+
+            int endOffset = scope.GetEndOffset();
+
+            // In PDBs emitted by VB the end offset is inclusive, 
+            // in PDBs emitted by C# the end offset is exclusive.
+            return isEndInclusive ? offset <= endOffset : offset < endOffset;
+        }
+
         /// <summary>
         /// Translates the value of a constant returned by <see cref="ISymUnmanagedConstant.GetValue(out object)"/> to a <see cref="ConstantValue"/>.
         /// </summary>
diff --git a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/MockSymUnmanaged.cs b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/MockSymUnmanaged.cs
index c3e01113f73c6..16e47e6ba3b1a 100644
--- a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/MockSymUnmanaged.cs
+++ b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/MockSymUnmanaged.cs
@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.Runtime.InteropServices.ComTypes;
 using Microsoft.DiaSymReader;
+using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Xunit;
 
@@ -32,12 +33,12 @@ public int GetMethodByVersion(int methodToken, int version, out ISymUnmanagedMet
             if (!_methodDebugInfoMap.TryGetValue(methodToken, out info))
             {
                 retVal = null;
-                return SymUnmanagedReaderExtensions.E_FAIL;
+                return HResult.E_FAIL;
             }
 
             Assert.NotNull(info);
             retVal = info.Method;
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
 
         public int GetSymAttribute(int methodToken, string name, int bufferLength, out int count, byte[] customDebugInformation)
@@ -58,12 +59,12 @@ public int GetSymAttributeByVersion(int methodToken, int version, string name, i
             if (!_methodDebugInfoMap.TryGetValue(methodToken, out info))
             {
                 count = 0;
-                return SymUnmanagedReaderExtensions.S_FALSE; // This is a guess.  We're not consuming it, so it doesn't really matter.
+                return HResult.S_FALSE; // This is a guess.  We're not consuming it, so it doesn't really matter.
             }
 
             Assert.NotNull(info);
             info.Bytes.TwoPhaseCopy(bufferLength, out count, customDebugInformation);
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
 
         public int GetDocument(string url, Guid language, Guid languageVendor, Guid documentType, out ISymUnmanagedDocument document)
@@ -169,13 +170,13 @@ public MockSymUnmanagedMethod(ISymUnmanagedScope rootScope)
         int ISymUnmanagedMethod.GetRootScope(out ISymUnmanagedScope retVal)
         {
             retVal = _rootScope;
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
 
         int ISymUnmanagedMethod.GetSequencePointCount(out int retVal)
         {
             retVal = 1;
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
 
         int ISymUnmanagedMethod.GetSequencePoints(int cPoints, out int pcPoints, int[] offsets, ISymUnmanagedDocument[] documents, int[] lines, int[] columns, int[] endLines, int[] endColumns)
@@ -187,7 +188,7 @@ int ISymUnmanagedMethod.GetSequencePoints(int cPoints, out int pcPoints, int[] o
             columns[0] = 0;
             endLines[0] = 0;
             endColumns[0] = 0;
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
 
         int ISymUnmanagedMethod.GetNamespace(out ISymUnmanagedNamespace retVal)
@@ -246,37 +247,37 @@ public MockSymUnmanagedScope(ImmutableArray<ISymUnmanagedScope> children, Immuta
         public int GetChildren(int numDesired, out int numRead, ISymUnmanagedScope[] buffer)
         {
             _children.TwoPhaseCopy(numDesired, out numRead, buffer);
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
 
         public int GetNamespaces(int numDesired, out int numRead, ISymUnmanagedNamespace[] buffer)
         {
             _namespaces.TwoPhaseCopy(numDesired, out numRead, buffer);
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
 
         public int GetStartOffset(out int pRetVal)
         {
             pRetVal = _startOffset;
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
 
         public int GetEndOffset(out int pRetVal)
         {
             pRetVal = _endOffset;
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
 
         public int GetLocalCount(out int pRetVal)
         {
             pRetVal = 0;
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
 
         public int GetLocals(int cLocals, out int pcLocals, ISymUnmanagedVariable[] locals)
         {
             pcLocals = 0;
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
 
         public int GetMethod(out ISymUnmanagedMethod pRetVal)
@@ -292,7 +293,7 @@ public int GetParent(out ISymUnmanagedScope pRetVal)
         public int GetConstantCount(out int pRetVal)
         {
             pRetVal = _constants.Length;
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
 
         public int GetConstants(int cConstants, out int pcConstants, ISymUnmanagedConstant[] constants)
@@ -302,7 +303,7 @@ public int GetConstants(int cConstants, out int pcConstants, ISymUnmanagedConsta
             {
                 Array.Copy(_constants, constants, constants.Length);
             }
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
     }
 
@@ -361,7 +362,7 @@ int ISymUnmanagedConstant.GetName(int bufferLength, out int count, char[] name)
             {
                 name[i] = _name[i];
             }
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
 
         int ISymUnmanagedConstant.GetSignature(int bufferLength, out int count, byte[] signature)
@@ -372,7 +373,7 @@ int ISymUnmanagedConstant.GetSignature(int bufferLength, out int count, byte[] s
         int ISymUnmanagedConstant.GetValue(out object value)
         {
             value = _value;
-            return SymUnmanagedReaderExtensions.S_OK;
+            return HResult.S_OK;
         }
     }
 
diff --git a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/NotImplementedSymUnmanaged.cs b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/NotImplementedSymUnmanaged.cs
index 46f8772ed1674..08215ac73df5c 100644
--- a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/NotImplementedSymUnmanaged.cs
+++ b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/NotImplementedSymUnmanaged.cs
@@ -1,9 +1,9 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
-using System.Diagnostics.SymbolStore;
 using System.Runtime.InteropServices.ComTypes;
 using Microsoft.DiaSymReader;
+using Roslyn.Test.Utilities;
 
 namespace Microsoft.CodeAnalysis.ExpressionEvaluator.UnitTests
 {
@@ -16,131 +16,131 @@ private NotImplementedSymUnmanagedReader() { }
         public int GetDocument(string url, Guid language, Guid languageVendor, Guid documentType, out ISymUnmanagedDocument retVal)
         {
             retVal = null;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetDocuments(int cDocs, out int pcDocs, ISymUnmanagedDocument[] pDocs)
         {
             pcDocs = 0;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetDocumentVersion(ISymUnmanagedDocument pDoc, out int version, out bool pbCurrent)
         {
             version = 0;
             pbCurrent = false;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetGlobalVariables(int cVars, out int pcVars, ISymUnmanagedVariable[] vars)
         {
             pcVars = 0;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetMethod(int methodToken, out ISymUnmanagedMethod retVal)
         {
             retVal = null;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetMethodByVersion(int methodToken, int version, out ISymUnmanagedMethod retVal)
         {
             retVal = null;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetMethodByVersionPreRemap(int methodToken, int version, out ISymUnmanagedMethod retVal)
         {
             retVal = null;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetMethodFromDocumentPosition(ISymUnmanagedDocument document, int line, int column, out ISymUnmanagedMethod retVal)
         {
             retVal = null;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetMethodsFromDocumentPosition(ISymUnmanagedDocument document, int line, int column, int cMethod, out int pcMethod, ISymUnmanagedMethod[] pRetVal)
         {
             pcMethod = 0;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetMethodsInDocument(ISymUnmanagedDocument document, int cMethod, out int pcMethod, ISymUnmanagedMethod[] methods)
         {
             pcMethod = 0;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetMethodVersion(ISymUnmanagedMethod pMethod, out int version)
         {
             version = 0;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetNamespaces(int cNameSpaces, out int pcNameSpaces, ISymUnmanagedNamespace[] namespaces)
         {
             pcNameSpaces = 0;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetSymAttribute(int parent, string name, int sizeBuffer, out int lengthBuffer, byte[] buffer)
         {
             lengthBuffer = 0;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetSymAttributeByVersion(int methodToken, int version, string name, int bufferLength, out int count, byte[] customDebugInformation)
         {
             count = 0;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetSymAttributeByVersionPreRemap(int methodToken, int version, string name, int bufferLength, out int count, byte[] customDebugInformation)
         {
             count = 0;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetSymAttributePreRemap(int parent, string name, int sizeBuffer, out int lengthBuffer, byte[] buffer)
         {
             lengthBuffer = 0;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetSymbolStoreFileName(int cchName, out int pcchName, char[] szName)
         {
             pcchName = 0;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetUserEntryPoint(out int EntryPoint)
         {
             EntryPoint = default(int);
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int GetVariables(int parent, int cVars, out int pcVars, ISymUnmanagedVariable[] vars)
         {
             pcVars = 0;
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int Initialize(object importer, string filename, string searchPath, IStream stream)
         {
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int ReplaceSymbolStore(string filename, IStream stream)
         {
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
 
         public int UpdateSymbolStore(string filename, IStream stream)
         {
-            return SymUnmanagedReaderExtensions.E_NOTIMPL;
+            return HResult.E_NOTIMPL;
         }
     }
 }
diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb
index a325d576e365d..dc4df811138a5 100644
--- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb
+++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb
@@ -3187,7 +3187,7 @@ End Module"
                         1,
                         Function(bufferLength As Integer, ByRef count As Integer, name() As Byte)
                             count = 0
-                            Return DiaSymReader.SymUnmanagedReaderExtensions.E_NOTIMPL
+                            Return HResult.E_NOTIMPL
                         End Function)
 
                     Dim debugInfo = New MethodDebugInfoBytes.Builder(constants:={badConst}).Build()
diff --git a/src/Test/PdbUtilities/Pdb/CustomDebugInfoUtilities.cs b/src/Test/PdbUtilities/Pdb/CustomDebugInfoUtilities.cs
index 5686ee2b29c91..2427dc143309f 100644
--- a/src/Test/PdbUtilities/Pdb/CustomDebugInfoUtilities.cs
+++ b/src/Test/PdbUtilities/Pdb/CustomDebugInfoUtilities.cs
@@ -12,7 +12,7 @@ public static class CustomDebugInfoUtilities
     {
         public static byte[] GetCustomDebugInfoBytes(ISymUnmanagedReader3 reader, MethodDefinitionHandle handle, int methodVersion)
         {
-            return reader.GetCustomDebugInfoBytes(MetadataTokens.GetToken(handle), methodVersion);
+            return reader.GetCustomDebugInfo(MetadataTokens.GetToken(handle), methodVersion);
         }
 
         public static ImmutableArray<byte> GetEditAndContinueLocalSlotMapRecord(byte[] customDebugInfoBlob)
diff --git a/src/Test/PdbUtilities/PdbUtilities.csproj b/src/Test/PdbUtilities/PdbUtilities.csproj
index 99b8198fb3066..1bd72d0917d5d 100644
--- a/src/Test/PdbUtilities/PdbUtilities.csproj
+++ b/src/Test/PdbUtilities/PdbUtilities.csproj
@@ -35,7 +35,6 @@
     <Compile Include="Shared\DateTimeUtilities.cs" />
     <Compile Include="Shared\DummyMetadataImport.cs" />
     <Compile Include="Shared\StringUtilities.cs" />
-    <Compile Include="Shared\SymUnmanagedReaderExtensions.cs" />
   </ItemGroup>
   <ItemGroup>
     <InternalsVisibleToTest Include="Roslyn.Compilers.UnitTests" />
diff --git a/src/Test/PdbUtilities/Shared/SymUnmanagedReaderExtensions.cs b/src/Test/PdbUtilities/Shared/SymUnmanagedReaderExtensions.cs
deleted file mode 100644
index d6a8c0894f1bd..0000000000000
--- a/src/Test/PdbUtilities/Shared/SymUnmanagedReaderExtensions.cs
+++ /dev/null
@@ -1,110 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System;
-using System.Collections.Immutable;
-using System.Diagnostics;
-using System.Linq;
-using System.Runtime.InteropServices;
-
-namespace Microsoft.DiaSymReader
-{
-    internal static class SymUnmanagedReaderExtensions
-    {
-        internal const int S_OK = 0x0;
-        internal const int S_FALSE = 0x1;
-        internal const int E_FAIL = unchecked((int)0x80004005);
-        internal const int E_NOTIMPL = unchecked((int)0x80004001);
-
-        private static readonly IntPtr s_ignoreIErrorInfo = new IntPtr(-1);
-
-        /// <summary>
-        /// Get the blob of binary custom debug info for a given method.
-        /// </summary>
-        public static byte[] GetCustomDebugInfoBytes(this ISymUnmanagedReader3 reader, int methodToken, int methodVersion)
-        {
-            try
-            {
-                return reader.GetCustomDebugInfo(methodToken, methodVersion);
-            }
-            catch (ArgumentOutOfRangeException)
-            {
-                // Sometimes the debugger returns the HRESULT for ArgumentOutOfRangeException, rather than E_FAIL,
-                // for methods without custom debug info (https://github.com/dotnet/roslyn/issues/4138).
-                return null;
-            }
-        }
-
-        internal static ImmutableArray<string> GetLocalVariableSlots(this ISymUnmanagedMethod method)
-        {
-            var builder = ImmutableArray.CreateBuilder<string>();
-            ISymUnmanagedScope rootScope = method.GetRootScope();
-
-            ForEachLocalVariableRecursive(rootScope, offset: -1, isScopeEndInclusive: false, action: local =>
-            {
-                int slot = local.GetSlot();
-                while (builder.Count <= slot)
-                {
-                    builder.Add(null);
-                }
-
-                var name = local.GetName();
-                builder[slot] = name;
-            });
-
-            return builder.ToImmutable();
-        }
-
-        private static void ForEachLocalVariableRecursive(
-            ISymUnmanagedScope scope,
-            int offset,
-            bool isScopeEndInclusive,
-            Action<ISymUnmanagedVariable> action)
-        {
-            Debug.Assert(offset < 0 || scope.IsInScope(offset, isScopeEndInclusive));
-
-            // apply action on locals of the current scope:
-            foreach (var local in scope.GetLocals())
-            {
-                action(local);
-            }
-
-            // recurse:
-            foreach (var child in scope.GetChildren())
-            {
-                if (offset < 0 || child.IsInScope(offset, isScopeEndInclusive))
-                {
-                    ForEachLocalVariableRecursive(child, offset, isScopeEndInclusive, action);
-                    if (offset >= 0)
-                    {
-                        return;
-                    }
-                }
-            }
-        }
-
-        internal static bool IsInScope(this ISymUnmanagedScope scope, int offset, bool isEndInclusive)
-        {
-            int startOffset = scope.GetStartOffset();
-            if (offset < startOffset)
-            {
-                return false;
-            }
-
-            int endOffset = scope.GetEndOffset();
-
-            // In PDBs emitted by VB the end offset is inclusive, 
-            // in PDBs emitted by C# the end offset is exclusive.
-            return isEndInclusive ? offset <= endOffset : offset < endOffset;
-        }
-
-        internal static void ThrowExceptionForHR(int hr)
-        {
-            // E_FAIL indicates "no info".
-            // E_NOTIMPL indicates a lack of ISymUnmanagedReader support (in a particular implementation).
-            if (hr < 0 && hr != E_FAIL && hr != E_NOTIMPL)
-            {
-                Marshal.ThrowExceptionForHR(hr, s_ignoreIErrorInfo);
-            }
-        }
-    }
-}
diff --git a/src/Test/Utilities/Portable/FX/HResult.cs b/src/Test/Utilities/Portable/FX/HResult.cs
new file mode 100644
index 0000000000000..0911433a41803
--- /dev/null
+++ b/src/Test/Utilities/Portable/FX/HResult.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+namespace Roslyn.Test.Utilities
+{
+    public static class HResult
+    {
+        public const int S_OK = 0x0;
+        public const int S_FALSE = 0x1;
+        public const int E_FAIL = unchecked((int)0x80004005);
+        public const int E_NOTIMPL = unchecked((int)0x80004001);
+    }
+}
diff --git a/src/Test/Utilities/Portable/TestUtilities.csproj b/src/Test/Utilities/Portable/TestUtilities.csproj
index e3878ae8dbbe6..d434232356b00 100644
--- a/src/Test/Utilities/Portable/TestUtilities.csproj
+++ b/src/Test/Utilities/Portable/TestUtilities.csproj
@@ -138,7 +138,8 @@
     <Compile Include="FX\EncodingUtilities.cs" />
     <Compile Include="FX\EnsureEnglishUICulture.cs" />
     <Compile Include="FX\EnsureInvariantCulture.cs" />
-    <Compile Include="FX\EventWaiter.cs" />
+    <Compile Include="FX\EventWaiter.cs" />    
+    <Compile Include="FX\HResult.cs" />
     <Compile Include="FX\ImmutableArrayTestExtensions.cs" />
     <Compile Include="FX\MonoHelpers.cs" />
     <Compile Include="FX\PinnedBlob.cs" />
diff --git a/src/VisualStudio/Core/Def/Implementation/EditAndContinue/VsENCRebuildableProjectImpl.cs b/src/VisualStudio/Core/Def/Implementation/EditAndContinue/VsENCRebuildableProjectImpl.cs
index a5de3f8df884e..243ffa85e036c 100644
--- a/src/VisualStudio/Core/Def/Implementation/EditAndContinue/VsENCRebuildableProjectImpl.cs
+++ b/src/VisualStudio/Core/Def/Implementation/EditAndContinue/VsENCRebuildableProjectImpl.cs
@@ -1205,7 +1205,13 @@ private static EditAndContinueMethodDebugInformation GetNativeEncDebugInfo(ISymU
             byte[] debugInfo;
             try
             {
-                debugInfo = symReader.GetCustomDebugInfoBytes(methodToken, methodVersion: 1);
+                debugInfo = symReader.GetCustomDebugInfo(methodToken, methodVersion: 1);
+            }
+            catch (ArgumentOutOfRangeException)
+            {
+                // Sometimes the debugger returns the HRESULT for ArgumentOutOfRangeException, rather than E_FAIL,
+                // for methods without custom debug info (https://github.com/dotnet/roslyn/issues/4138).
+                debugInfo = null;
             }
             catch (Exception e) when (FatalError.ReportWithoutCrash(e)) // likely a bug in the compiler/debugger
             {
diff --git a/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj b/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
index 2ed5cbcfd314c..5dbde39587d3e 100644
--- a/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
+++ b/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
@@ -212,11 +212,6 @@
       <DependentUpon>VSPackage.resx</DependentUpon>
     </Compile>
   </ItemGroup>
-  <ItemGroup Label="Linked Files">
-    <Compile Include="..\..\..\Test\PdbUtilities\Shared\SymUnmanagedReaderExtensions.cs">
-      <Link>Shared\SymUnmanagedReaderExtensions.cs</Link>
-    </Compile>
-  </ItemGroup>
   <ItemGroup Label="Project References">
     <ProjectReference Include="..\..\..\Compilers\Core\Portable\CodeAnalysis.csproj">
       <Project>{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}</Project>

From 3994dc4981f68772dfec50f224f9606a06f97e8f Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Fri, 12 May 2017 14:06:52 -0700
Subject: [PATCH 149/284] Added assertForeground flag to constructor

---
 .../Def/Experimentation/VisualStudioExperimentationService.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Experimentation/VisualStudioExperimentationService.cs b/src/VisualStudio/Core/Def/Experimentation/VisualStudioExperimentationService.cs
index 96503af8825b6..e94cdf50c400e 100644
--- a/src/VisualStudio/Core/Def/Experimentation/VisualStudioExperimentationService.cs
+++ b/src/VisualStudio/Core/Def/Experimentation/VisualStudioExperimentationService.cs
@@ -17,8 +17,8 @@ internal class VisualStudioExperimentationService : ForegroundThreadAffinitizedO
         private readonly MethodInfo _isCachedFlightEnabledInfo;
 
         [ImportingConstructor]
-        public VisualStudioExperimentationService(
-            SVsServiceProvider serviceProvider)
+        public VisualStudioExperimentationService(SVsServiceProvider serviceProvider) :
+            base(assertIsForeground: true)
         {
             try
             {

From 479d1f1d844b5d9ff07b215ef1781aa7919372a8 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Fri, 12 May 2017 14:14:26 -0700
Subject: [PATCH 150/284] Move all checks to foreground thread

---
 .../AnalyzerVsixSuggestedActionCallback.cs    | 69 ++++---------------
 1 file changed, 15 insertions(+), 54 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
index a53112822b7ad..5f3efbde83954 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -1,18 +1,14 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
-using System.Collections.Generic;
 using System.ComponentModel.Composition;
-using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Implementation.Suggestions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Experiments;
 using Microsoft.CodeAnalysis.Extensions;
 using Microsoft.CodeAnalysis.Options;
-using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
-using Task = System.Threading.Tasks.Task;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.Experimentation
 {
@@ -24,33 +20,26 @@ internal class AnalyzerVsixSuggestedActionCallback : ForegroundThreadAffinitized
         private static readonly Guid FxCopAnalyzersPackageGuid = Guid.Parse("{4A41D270-A97F-4639-A352-28732FC410E4}");
 
         private readonly VisualStudioWorkspace _workspace;
-        private readonly IForegroundNotificationService _foregroundNotificationService;
-        private readonly IAsynchronousOperationListener _operationListener;
         private readonly SVsServiceProvider _serviceProvider;
 
-        private readonly object _scheduleLock = new object();
-        // If we are currently checking to see if the user fits the treatment profile, then we don't want to schedule another check
-        private bool _checksRunning = false;
         // We don't show the user an infobar more than once per VS session
         private bool _infoBarShown = false;
-        private FxCopInstallStatus _installStatus = FxCopInstallStatus.Unchecked;
+        private LiveCAInstallStatus _installStatus = LiveCAInstallStatus.Unchecked;
         // Initialized the first time we're on the UI thread
         private IExperimentationService _experimentationService;
 
         [ImportingConstructor]
         public AnalyzerVsixSuggestedActionCallback(VisualStudioWorkspace workspace,
-            IForegroundNotificationService foregroundNotificationService,
-            [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners,
             SVsServiceProvider serviceProvider)
         {
             _workspace = workspace;
-            _foregroundNotificationService = foregroundNotificationService;
-            _operationListener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.ABTest);
             _serviceProvider = serviceProvider;
         }
 
         public void OnSuggestedActionExecuted(SuggestedAction action)
         {
+            // If the experimentation service hasn't been retrieved, we'll need to be on the UI
+            // thread to get it
             AssertIsForeground();
 
             // Initialize the experimentation service if it hasn't yet been fetched
@@ -60,46 +49,32 @@ public void OnSuggestedActionExecuted(SuggestedAction action)
             }
 
             // If we haven't yet checked to see if the VSIX is installed, check now
-            if (_installStatus == FxCopInstallStatus.Unchecked)
+            if (_installStatus == LiveCAInstallStatus.Unchecked)
             {
                 var vsShell = _serviceProvider.GetService(typeof(SVsShell)) as IVsShell;
                 ErrorHandler.ThrowOnFailure(vsShell.IsPackageInstalled(FxCopAnalyzersPackageGuid, out int installed));
-                _installStatus = installed != 0 ? FxCopInstallStatus.Installed : FxCopInstallStatus.NotInstalled;
+                _installStatus = installed != 0 ? LiveCAInstallStatus.Installed : LiveCAInstallStatus.NotInstalled;
             }
 
             // Only proceed if the VSIX isn't installed
-            if (_installStatus == FxCopInstallStatus.Installed)
+            if (_installStatus == LiveCAInstallStatus.Installed)
             {
                 return;
             }
 
-            lock (_scheduleLock)
+            if (!_infoBarShown)
             {
-                if (!_checksRunning && !_infoBarShown)
-                {
-                    _checksRunning = true;
-                    Task.Run((Action)SuggestedActionOccurred);
-                }
+                SuggestedActionOccurred();
             }
         }
 
         private void SuggestedActionOccurred()
         {
-            // We don't need to do this work on the UI thread
-            AssertIsBackground();
-
             var options = _workspace.Options;
 
             // If the user has previously clicked don't show again, then we bail out immediately
             if (options.GetOption(AnalyzerABTestOptions.NeverShowAgain))
             {
-                // We set _infoBarShown to true here to make sure that we never run these checks again
-                lock(_scheduleLock)
-                {
-                    _checksRunning = false;
-                    _infoBarShown = true;
-                }
-
                 return;
             }
 
@@ -131,14 +106,10 @@ private void SuggestedActionOccurred()
                 }
             }
 
-            // If the user still isn't a candidate, then return. Otherwise, we move to checking if the infobar should be shown
+            // If the user still isn't a candidate, then return. Otherwise, we move to checking if
+            // the infobar should be shown
             if (!isCandidate)
             {
-                lock (_scheduleLock)
-                {
-                    _checksRunning = false;
-                }
-
                 return;
             }
 
@@ -149,8 +120,9 @@ private void ShowInfoBarIfNecessary()
         {
             if (_experimentationService.IsExperimentEnabled(AnalyzerEnabledFlight))
             {
-                // If we got true from the experimentation service, then we're in the treatment group, and the experiment is enabled.
-                // We determine if the infobar has been displayed in the past 24 hours. If it hasn't been displayed, then we do so now.
+                // If we got true from the experimentation service, then we're in the treatment
+                // group, and the experiment is enabled. We determine if the infobar has been
+                // displayed in the past 24 hours. If it hasn't been displayed, then we do so now.
                 var lastDayInfoBarShown = DateTime.FromBinary(_workspace.Options.GetOption(AnalyzerABTestOptions.LastDayInfoBarShown));
                 var utcNow = DateTime.UtcNow;
                 var timeSinceLastShown = utcNow - lastDayInfoBarShown;
@@ -171,18 +143,7 @@ private void ShowInfoBarIfNecessary()
                                       kind: InfoBarUI.UIKind.Button,
                                       action: DoNotShowAgain));
 
-                    lock(_scheduleLock)
-                    {
-                        _checksRunning = false;
-                        _infoBarShown = true;
-                    }
-                }
-            }
-            else
-            {
-                lock(_scheduleLock)
-                {
-                    _checksRunning = false;
+                    _infoBarShown = true;
                 }
             }
         }
@@ -197,7 +158,7 @@ private void DoNotShowAgain()
             _workspace.Options = _workspace.Options.WithChangedOption(AnalyzerABTestOptions.NeverShowAgain, true);
         }
 
-        private enum FxCopInstallStatus
+        private enum LiveCAInstallStatus
         {
             Unchecked,
             Installed,

From cbda7ae4ee3f59fe5d6824574de00f9e90c0eeef Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Fri, 12 May 2017 14:15:17 -0700
Subject: [PATCH 151/284] Updated fwlink

---
 .../Experimentation/AnalyzerVsixSuggestedActionCallback.cs      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
index 5f3efbde83954..5eaeb64fa90f0 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -16,7 +16,7 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.Experimentation
     internal class AnalyzerVsixSuggestedActionCallback : ForegroundThreadAffinitizedObject, ISuggestedActionCallback
     {
         private const string AnalyzerEnabledFlight = @"LiveCA/LiveCAcf";
-        private const string AnalyzerVsixHyperlink = @"https://aka.ms/livecodeanalysis";
+        private const string AnalyzerVsixHyperlink = @"https://go.microsoft.com/fwlink/?linkid=849061";
         private static readonly Guid FxCopAnalyzersPackageGuid = Guid.Parse("{4A41D270-A97F-4639-A352-28732FC410E4}");
 
         private readonly VisualStudioWorkspace _workspace;

From 5eb7ed306bc43fcdad7ac7ec4acc3e7fe17f8096 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Fri, 12 May 2017 14:21:52 -0700
Subject: [PATCH 152/284] Removed extraneous itemgroup

---
 src/VisualStudio/Core/Def/ServicesVisualStudio.csproj | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj b/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
index ac3b8ac9c1909..aa9f418a2b8dd 100644
--- a/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
+++ b/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
@@ -802,7 +802,6 @@
       <SubType>Designer</SubType>
     </VSCTCompile>
   </ItemGroup>
-  <ItemGroup />
   <Import Project="..\..\..\Dependencies\CodeAnalysis.Metadata\Microsoft.CodeAnalysis.Metadata.projitems" Label="Shared" />
   <Import Project="..\..\..\..\build\Targets\Imports.targets" />
 </Project>
\ No newline at end of file

From 80fd73eba654cfe4f4cb626cfc7c598ccdf6bf66 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Fri, 12 May 2017 14:32:44 -0700
Subject: [PATCH 153/284] ReportWithoutCrash for failing to find whether the
 VSIX is installed

---
 .../AnalyzerVsixSuggestedActionCallback.cs         | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
index 5eaeb64fa90f0..e567b29abb614 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -2,8 +2,10 @@
 
 using System;
 using System.ComponentModel.Composition;
+using System.Runtime.InteropServices;
 using Microsoft.CodeAnalysis.Editor.Implementation.Suggestions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Experiments;
 using Microsoft.CodeAnalysis.Extensions;
 using Microsoft.CodeAnalysis.Options;
@@ -52,7 +54,17 @@ public void OnSuggestedActionExecuted(SuggestedAction action)
             if (_installStatus == LiveCAInstallStatus.Unchecked)
             {
                 var vsShell = _serviceProvider.GetService(typeof(SVsShell)) as IVsShell;
-                ErrorHandler.ThrowOnFailure(vsShell.IsPackageInstalled(FxCopAnalyzersPackageGuid, out int installed));
+                var hr = vsShell.IsPackageInstalled(FxCopAnalyzersPackageGuid, out int installed);
+                if (ErrorHandler.Failed(hr))
+                {
+                    FatalError.ReportWithoutCrash(Marshal.GetExceptionForHR(hr));
+
+                    // We set installed to ensure we don't go through this again next time a
+                    // suggested action is called, and we don't want to continue if the shell
+                    // is busted.
+                    _installStatus = LiveCAInstallStatus.Installed;
+                    return;
+                }
                 _installStatus = installed != 0 ? LiveCAInstallStatus.Installed : LiveCAInstallStatus.NotInstalled;
             }
 

From b7fc91d8540fa2c0c5271e4a4f0d7236527f1756 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Fri, 12 May 2017 14:35:01 -0700
Subject: [PATCH 154/284] Added infodoc

---
 .../AnalyzerVsixSuggestedActionCallback.cs           | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
index e567b29abb614..57def37422be5 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -24,12 +24,18 @@ internal class AnalyzerVsixSuggestedActionCallback : ForegroundThreadAffinitized
         private readonly VisualStudioWorkspace _workspace;
         private readonly SVsServiceProvider _serviceProvider;
 
-        // We don't show the user an infobar more than once per VS session
+        /// <summary>
+        /// Tracks when the bar is shown so we don't show to the user more than once per session
+        /// </summary>
         private bool _infoBarShown = false;
-        private LiveCAInstallStatus _installStatus = LiveCAInstallStatus.Unchecked;
-        // Initialized the first time we're on the UI thread
+
+        /// <summary>
+        /// This service is initialzed by <see cref="OnSuggestedActionExecuted(SuggestedAction)"/>
+        /// </summary>
         private IExperimentationService _experimentationService;
 
+        private LiveCAInstallStatus _installStatus = LiveCAInstallStatus.Unchecked;
+
         [ImportingConstructor]
         public AnalyzerVsixSuggestedActionCallback(VisualStudioWorkspace workspace,
             SVsServiceProvider serviceProvider)

From 1bb1b4553f804499a87f34c6f0610e48e456f4d0 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Fri, 12 May 2017 14:35:45 -0700
Subject: [PATCH 155/284] Wrap long comment

---
 .../Experimentation/AnalyzerVsixSuggestedActionCallback.cs     | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
index 57def37422be5..5b391a5d00375 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -100,7 +100,8 @@ private void SuggestedActionOccurred()
             //     1: Are a Dotnet user (as evidenced by the fact that this code is being run)
             //     2: Have triggered a lightbulb on 3 separate days
 
-            // If the user hasn't met candidacy conditions, then we check them. Otherwise, proceed to info bar check
+            // If the user hasn't met candidacy conditions, then we check them. Otherwise, proceed
+            // to info bar check
             var isCandidate = options.GetOption(AnalyzerABTestOptions.HasMetCandidacyRequirements);
             if (!isCandidate)
             {

From 1d11b70f6bf07d11b3f9d055a6bc2e8e6186e016 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Fri, 12 May 2017 15:01:30 -0700
Subject: [PATCH 156/284] Refactored types

---
 .../TestHooks/FeatureAttribute_Names.cs       |  1 -
 .../VisualStudioExperimentationService.cs     |  4 +-
 .../Experimentation/AnalyzerABTestOptions.cs  | 34 ++++++++++
 .../AnalyzerVsixSuggestedActionCallback.cs    | 68 +++++--------------
 .../LiveCodeAnalysisInstallStatus.cs          | 11 +++
 .../Core/Def/ServicesVisualStudio.csproj      |  2 +
 6 files changed, 66 insertions(+), 54 deletions(-)
 create mode 100644 src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerABTestOptions.cs
 create mode 100644 src/VisualStudio/Core/Def/Implementation/Experimentation/LiveCodeAnalysisInstallStatus.cs

diff --git a/src/Features/Core/Portable/Shared/TestHooks/FeatureAttribute_Names.cs b/src/Features/Core/Portable/Shared/TestHooks/FeatureAttribute_Names.cs
index 43df164421c7b..d91c697922975 100644
--- a/src/Features/Core/Portable/Shared/TestHooks/FeatureAttribute_Names.cs
+++ b/src/Features/Core/Portable/Shared/TestHooks/FeatureAttribute_Names.cs
@@ -4,7 +4,6 @@ namespace Microsoft.CodeAnalysis.Shared.TestHooks
 {
     internal partial class FeatureAttribute
     {
-        public const string ABTest = nameof(ABTest);
         public const string AutomaticEndConstructCorrection = nameof(AutomaticEndConstructCorrection);
         public const string AutomaticPairCompletion = nameof(AutomaticPairCompletion);
         public const string BraceHighlighting = nameof(BraceHighlighting);
diff --git a/src/VisualStudio/Core/Def/Experimentation/VisualStudioExperimentationService.cs b/src/VisualStudio/Core/Def/Experimentation/VisualStudioExperimentationService.cs
index e94cdf50c400e..c7641e630a3de 100644
--- a/src/VisualStudio/Core/Def/Experimentation/VisualStudioExperimentationService.cs
+++ b/src/VisualStudio/Core/Def/Experimentation/VisualStudioExperimentationService.cs
@@ -17,8 +17,8 @@ internal class VisualStudioExperimentationService : ForegroundThreadAffinitizedO
         private readonly MethodInfo _isCachedFlightEnabledInfo;
 
         [ImportingConstructor]
-        public VisualStudioExperimentationService(SVsServiceProvider serviceProvider) :
-            base(assertIsForeground: true)
+        public VisualStudioExperimentationService(SVsServiceProvider serviceProvider)
+            : base(assertIsForeground: true)
         {
             try
             {
diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerABTestOptions.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerABTestOptions.cs
new file mode 100644
index 0000000000000..f0ed5683e282d
--- /dev/null
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerABTestOptions.cs
@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using Microsoft.CodeAnalysis.Options;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.Experimentation
+{
+    internal static class AnalyzerABTestOptions
+    {
+        private const string LocalRegistryPath = @"Roslyn\Internal\Analyzers\AB\Vsix\";
+
+        [ExportOption]
+        public static readonly Option<long> LastDateTimeUsedSuggestionAction = new Option<long>(nameof(AnalyzerABTestOptions),
+            nameof(LastDateTimeUsedSuggestionAction), defaultValue: DateTime.MinValue.ToBinary(),
+            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(LastDateTimeUsedSuggestionAction)));
+
+        [ExportOption]
+        public static readonly Option<uint> UsedSuggestedActionCount = new Option<uint>(nameof(AnalyzerABTestOptions), nameof(UsedSuggestedActionCount),
+            defaultValue: 0, storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(UsedSuggestedActionCount)));
+
+        [ExportOption]
+        public static readonly Option<bool> NeverShowAgain = new Option<bool>(nameof(AnalyzerABTestOptions), nameof(NeverShowAgain),
+            defaultValue: false, storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(NeverShowAgain)));
+
+        [ExportOption]
+        public static readonly Option<bool> HasMetCandidacyRequirements = new Option<bool>(nameof(AnalyzerABTestOptions), nameof(HasMetCandidacyRequirements),
+            defaultValue: false, storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(HasMetCandidacyRequirements)));
+
+        [ExportOption]
+        public static readonly Option<long> LastDateTimeInfoBarShown = new Option<long>(nameof(AnalyzerABTestOptions), nameof(LastDateTimeInfoBarShown),
+            defaultValue: DateTime.MinValue.ToBinary(),
+            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(LastDateTimeInfoBarShown)));
+    }
+}
diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
index 5b391a5d00375..84cf67014c2e9 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -8,7 +8,6 @@
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Experiments;
 using Microsoft.CodeAnalysis.Extensions;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
 
@@ -34,10 +33,11 @@ internal class AnalyzerVsixSuggestedActionCallback : ForegroundThreadAffinitized
         /// </summary>
         private IExperimentationService _experimentationService;
 
-        private LiveCAInstallStatus _installStatus = LiveCAInstallStatus.Unchecked;
+        private LiveCodeAnalysisInstallStatus _installStatus = LiveCodeAnalysisInstallStatus.Unknown;
 
         [ImportingConstructor]
-        public AnalyzerVsixSuggestedActionCallback(VisualStudioWorkspace workspace,
+        public AnalyzerVsixSuggestedActionCallback(
+            VisualStudioWorkspace workspace,
             SVsServiceProvider serviceProvider)
         {
             _workspace = workspace;
@@ -50,6 +50,12 @@ public void OnSuggestedActionExecuted(SuggestedAction action)
             // thread to get it
             AssertIsForeground();
 
+            // If the user has previously clicked don't show again, then we bail out immediately
+            if (_workspace.Options.GetOption(AnalyzerABTestOptions.NeverShowAgain))
+            {
+                return;
+            }
+
             // Initialize the experimentation service if it hasn't yet been fetched
             if (_experimentationService == null)
             {
@@ -57,7 +63,7 @@ public void OnSuggestedActionExecuted(SuggestedAction action)
             }
 
             // If we haven't yet checked to see if the VSIX is installed, check now
-            if (_installStatus == LiveCAInstallStatus.Unchecked)
+            if (_installStatus == LiveCodeAnalysisInstallStatus.Unknown)
             {
                 var vsShell = _serviceProvider.GetService(typeof(SVsShell)) as IVsShell;
                 var hr = vsShell.IsPackageInstalled(FxCopAnalyzersPackageGuid, out int installed);
@@ -68,14 +74,14 @@ public void OnSuggestedActionExecuted(SuggestedAction action)
                     // We set installed to ensure we don't go through this again next time a
                     // suggested action is called, and we don't want to continue if the shell
                     // is busted.
-                    _installStatus = LiveCAInstallStatus.Installed;
+                    _installStatus = LiveCodeAnalysisInstallStatus.Installed;
                     return;
                 }
-                _installStatus = installed != 0 ? LiveCAInstallStatus.Installed : LiveCAInstallStatus.NotInstalled;
+                _installStatus = installed != 0 ? LiveCodeAnalysisInstallStatus.Installed : LiveCodeAnalysisInstallStatus.NotInstalled;
             }
 
             // Only proceed if the VSIX isn't installed
-            if (_installStatus == LiveCAInstallStatus.Installed)
+            if (_installStatus == LiveCodeAnalysisInstallStatus.Installed)
             {
                 return;
             }
@@ -90,12 +96,6 @@ private void SuggestedActionOccurred()
         {
             var options = _workspace.Options;
 
-            // If the user has previously clicked don't show again, then we bail out immediately
-            if (options.GetOption(AnalyzerABTestOptions.NeverShowAgain))
-            {
-                return;
-            }
-
             // Filter for valid A/B test candidates. Candidates fill the following critera:
             //     1: Are a Dotnet user (as evidenced by the fact that this code is being run)
             //     2: Have triggered a lightbulb on 3 separate days
@@ -106,12 +106,12 @@ private void SuggestedActionOccurred()
             if (!isCandidate)
             {
                 // We store in UTC to avoid any timezone offset weirdness
-                var lastTriggeredTime = DateTime.FromBinary(options.GetOption(AnalyzerABTestOptions.LastDayUsedSuggestionAction));
+                var lastTriggeredTime = DateTime.FromBinary(options.GetOption(AnalyzerABTestOptions.LastDateTimeUsedSuggestionAction));
                 var currentTime = DateTime.UtcNow;
                 var span = currentTime - lastTriggeredTime;
                 if (span.TotalDays >= 1)
                 {
-                    options = options.WithChangedOption(AnalyzerABTestOptions.LastDayUsedSuggestionAction, currentTime.ToBinary());
+                    options = options.WithChangedOption(AnalyzerABTestOptions.LastDateTimeUsedSuggestionAction, currentTime.ToBinary());
                     var usageCount = options.GetOption(AnalyzerABTestOptions.UsedSuggestedActionCount);
                     usageCount++;
                     options = options.WithChangedOption(AnalyzerABTestOptions.UsedSuggestedActionCount, usageCount);
@@ -142,13 +142,13 @@ private void ShowInfoBarIfNecessary()
                 // If we got true from the experimentation service, then we're in the treatment
                 // group, and the experiment is enabled. We determine if the infobar has been
                 // displayed in the past 24 hours. If it hasn't been displayed, then we do so now.
-                var lastDayInfoBarShown = DateTime.FromBinary(_workspace.Options.GetOption(AnalyzerABTestOptions.LastDayInfoBarShown));
+                var lastDayInfoBarShown = DateTime.FromBinary(_workspace.Options.GetOption(AnalyzerABTestOptions.LastDateTimeInfoBarShown));
                 var utcNow = DateTime.UtcNow;
                 var timeSinceLastShown = utcNow - lastDayInfoBarShown;
 
                 if (timeSinceLastShown.TotalDays >= 1)
                 {
-                    _workspace.Options = _workspace.Options.WithChangedOption(AnalyzerABTestOptions.LastDayInfoBarShown, utcNow.ToBinary());
+                    _workspace.Options = _workspace.Options.WithChangedOption(AnalyzerABTestOptions.LastDateTimeInfoBarShown, utcNow.ToBinary());
 
                     var infoBarService = _workspace.Services.GetRequiredService<IInfoBarService>();
                     infoBarService.ShowInfoBarInGlobalView(
@@ -176,39 +176,5 @@ private void DoNotShowAgain()
         {
             _workspace.Options = _workspace.Options.WithChangedOption(AnalyzerABTestOptions.NeverShowAgain, true);
         }
-
-        private enum LiveCAInstallStatus
-        {
-            Unchecked,
-            Installed,
-            NotInstalled
-        }
-    }
-
-    internal static class AnalyzerABTestOptions
-    {
-        private const string LocalRegistryPath = @"Roslyn\Internal\Analyzers\AB\Vsix\";
-
-        [ExportOption]
-        public static readonly Option<long> LastDayUsedSuggestionAction = new Option<long>(nameof(AnalyzerABTestOptions), nameof(LastDayUsedSuggestionAction),
-            defaultValue: DateTime.MinValue.ToBinary(),
-            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(LastDayUsedSuggestionAction)));
-
-        [ExportOption]
-        public static readonly Option<uint> UsedSuggestedActionCount = new Option<uint>(nameof(AnalyzerABTestOptions), nameof(UsedSuggestedActionCount),
-            defaultValue: 0, storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(UsedSuggestedActionCount)));
-
-        [ExportOption]
-        public static readonly Option<bool> NeverShowAgain = new Option<bool>(nameof(AnalyzerABTestOptions), nameof(NeverShowAgain),
-            defaultValue: false, storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(NeverShowAgain)));
-
-        [ExportOption]
-        public static readonly Option<bool> HasMetCandidacyRequirements = new Option<bool>(nameof(AnalyzerABTestOptions), nameof(HasMetCandidacyRequirements),
-            defaultValue: false, storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(HasMetCandidacyRequirements)));
-
-        [ExportOption]
-        public static readonly Option<long> LastDayInfoBarShown = new Option<long>(nameof(AnalyzerABTestOptions), nameof(LastDayInfoBarShown),
-            defaultValue: DateTime.MinValue.ToBinary(),
-            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(LastDayInfoBarShown)));
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/LiveCodeAnalysisInstallStatus.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/LiveCodeAnalysisInstallStatus.cs
new file mode 100644
index 0000000000000..39ff06483f010
--- /dev/null
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/LiveCodeAnalysisInstallStatus.cs
@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.Experimentation
+{
+    internal enum LiveCodeAnalysisInstallStatus
+    {
+        Unknown,
+        Installed,
+        NotInstalled
+    }
+}
\ No newline at end of file
diff --git a/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj b/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
index aa9f418a2b8dd..43c7d75c428b5 100644
--- a/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
+++ b/src/VisualStudio/Core/Def/ServicesVisualStudio.csproj
@@ -63,6 +63,8 @@
     <Compile Include="Implementation\AnalyzerDependency\IIgnorableAssemblyList.cs" />
     <Compile Include="Implementation\AnalyzerDependency\IBindingRedirectionService.cs" />
     <Compile Include="Implementation\Experimentation\AnalyzerVsixSuggestedActionCallback.cs" />
+    <Compile Include="Implementation\Experimentation\AnalyzerABTestOptions.cs" />
+    <Compile Include="Implementation\Experimentation\LiveCodeAnalysisInstallStatus.cs" />
     <Compile Include="Implementation\Extensions\ServiceProviderExtensions.cs" />
     <Compile Include="ID.InteractiveCommands.cs" />
     <Compile Include="Implementation\FindReferences\VisualStudioDefinitionsAndReferencesFactory.cs" />

From efd8b644bbbdcf0c25b6085906a581fe7bcf51e0 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Fri, 12 May 2017 15:15:32 -0700
Subject: [PATCH 157/284] Refactored logic into helpers.

---
 .../AnalyzerVsixSuggestedActionCallback.cs    | 56 +++++++++----------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
index 84cf67014c2e9..8296361148e1b 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -56,13 +56,29 @@ public void OnSuggestedActionExecuted(SuggestedAction action)
                 return;
             }
 
+            EnsureInitialized();
+
+            // Only show if the VSIX is not installed, the info bar hasn't been shown this session,
+            // and the user is an A/B test candidate
+            if (!IsVsixInstalled() &&
+                !_infoBarShown &&
+                IsCandidate())
+            {
+                ShowInfoBarIfNecessary();
+            }
+        }
+
+        private void EnsureInitialized()
+        {
             // Initialize the experimentation service if it hasn't yet been fetched
             if (_experimentationService == null)
             {
                 _experimentationService = _workspace.Services.GetRequiredService<IExperimentationService>();
             }
+        }
 
-            // If we haven't yet checked to see if the VSIX is installed, check now
+        private bool IsVsixInstalled()
+        {
             if (_installStatus == LiveCodeAnalysisInstallStatus.Unknown)
             {
                 var vsShell = _serviceProvider.GetService(typeof(SVsShell)) as IVsShell;
@@ -75,33 +91,25 @@ public void OnSuggestedActionExecuted(SuggestedAction action)
                     // suggested action is called, and we don't want to continue if the shell
                     // is busted.
                     _installStatus = LiveCodeAnalysisInstallStatus.Installed;
-                    return;
                 }
-                _installStatus = installed != 0 ? LiveCodeAnalysisInstallStatus.Installed : LiveCodeAnalysisInstallStatus.NotInstalled;
-            }
-
-            // Only proceed if the VSIX isn't installed
-            if (_installStatus == LiveCodeAnalysisInstallStatus.Installed)
-            {
-                return;
+                else
+                {
+                    _installStatus = installed != 0 ? LiveCodeAnalysisInstallStatus.Installed : LiveCodeAnalysisInstallStatus.NotInstalled;
+                }
             }
 
-            if (!_infoBarShown)
-            {
-                SuggestedActionOccurred();
-            }
+            return _installStatus == LiveCodeAnalysisInstallStatus.Installed;
         }
 
-        private void SuggestedActionOccurred()
+        private bool IsCandidate()
         {
-            var options = _workspace.Options;
-
             // Filter for valid A/B test candidates. Candidates fill the following critera:
             //     1: Are a Dotnet user (as evidenced by the fact that this code is being run)
             //     2: Have triggered a lightbulb on 3 separate days
 
             // If the user hasn't met candidacy conditions, then we check them. Otherwise, proceed
             // to info bar check
+            var options = _workspace.Options;
             var isCandidate = options.GetOption(AnalyzerABTestOptions.HasMetCandidacyRequirements);
             if (!isCandidate)
             {
@@ -125,14 +133,7 @@ private void SuggestedActionOccurred()
                 }
             }
 
-            // If the user still isn't a candidate, then return. Otherwise, we move to checking if
-            // the infobar should be shown
-            if (!isCandidate)
-            {
-                return;
-            }
-
-            ShowInfoBarIfNecessary();
+            return isCandidate;
         }
 
         private void ShowInfoBarIfNecessary()
@@ -142,12 +143,13 @@ private void ShowInfoBarIfNecessary()
                 // If we got true from the experimentation service, then we're in the treatment
                 // group, and the experiment is enabled. We determine if the infobar has been
                 // displayed in the past 24 hours. If it hasn't been displayed, then we do so now.
-                var lastDayInfoBarShown = DateTime.FromBinary(_workspace.Options.GetOption(AnalyzerABTestOptions.LastDateTimeInfoBarShown));
+                var lastTimeInfoBarShown = DateTime.FromBinary(_workspace.Options.GetOption(AnalyzerABTestOptions.LastDateTimeInfoBarShown));
                 var utcNow = DateTime.UtcNow;
-                var timeSinceLastShown = utcNow - lastDayInfoBarShown;
+                var timeSinceLastShown = utcNow - lastTimeInfoBarShown;
 
                 if (timeSinceLastShown.TotalDays >= 1)
                 {
+                    _infoBarShown = true;
                     _workspace.Options = _workspace.Options.WithChangedOption(AnalyzerABTestOptions.LastDateTimeInfoBarShown, utcNow.ToBinary());
 
                     var infoBarService = _workspace.Services.GetRequiredService<IInfoBarService>();
@@ -161,8 +163,6 @@ private void ShowInfoBarIfNecessary()
                         new InfoBarUI(title: ServicesVSResources.Analyzer_vsix_do_not_show_again,
                                       kind: InfoBarUI.UIKind.Button,
                                       action: DoNotShowAgain));
-
-                    _infoBarShown = true;
                 }
             }
         }

From e695bf017a0eb04b07107ef413192d1eebdd1bf2 Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Fri, 12 May 2017 16:14:19 -0700
Subject: [PATCH 158/284] Add a common base type of IDE and diagnostics VS
 performance tests.

---
 src/Test/Perf/Utilities/Perf.Utilities.csproj |   1 +
 src/Test/Perf/Utilities/VsPerfTest.cs         | 119 ++++++++++++++++++
 2 files changed, 120 insertions(+)
 create mode 100644 src/Test/Perf/Utilities/VsPerfTest.cs

diff --git a/src/Test/Perf/Utilities/Perf.Utilities.csproj b/src/Test/Perf/Utilities/Perf.Utilities.csproj
index a4de6e8e43271..e2988e2b84a8d 100644
--- a/src/Test/Perf/Utilities/Perf.Utilities.csproj
+++ b/src/Test/Perf/Utilities/Perf.Utilities.csproj
@@ -32,6 +32,7 @@
     <Compile Include="Logger.cs" />
     <Compile Include="PerfTestBase.cs" />
     <Compile Include="RelativeDirectory.cs" />
+    <Compile Include="VsPerfTest.cs" />
     <Compile Include="ScenarioGenerator.cs" />
     <Compile Include="TestUtilities.cs" />
     <Compile Include="TraceManager.cs" />
diff --git a/src/Test/Perf/Utilities/VsPerfTest.cs b/src/Test/Perf/Utilities/VsPerfTest.cs
new file mode 100644
index 0000000000000..2470d366a7592
--- /dev/null
+++ b/src/Test/Perf/Utilities/VsPerfTest.cs
@@ -0,0 +1,119 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.IO;
+using static Roslyn.Test.Performance.Utilities.TestUtilities;
+
+namespace Roslyn.Test.Performance.Utilities
+{
+    public abstract class VsPerfTest : PerfTest
+    {
+        private static readonly string _rootSuffix = "RoslynPerf";
+
+        private readonly ILogger _logger;
+        private readonly string _testTemplateName;
+        private readonly string _testName;
+        private readonly string _zipFileToDownload;
+        private readonly int _zipFileVersion;
+        private readonly string _solutionToTest;
+        private readonly string _benchviewUploadName;
+        private readonly string[] _scenarios;
+        private static readonly string _nugetPackagesPath = System.Environment.GetEnvironmentVariable("NUGET_PACKAGES") ??
+            Path.Combine(System.Environment.GetEnvironmentVariable("UserProfile"), ".nuget", "packages");
+        private static readonly string _installerPath = Path.Combine(_nugetPackagesPath, "roslyntools.microsoft.vsixexpinstaller", "0.2.4-beta", "tools", "vsixexpinstaller.exe");
+
+        public VsPerfTest(
+            string testTemplateName,
+            string testName,
+            string solutionToTest,
+            string benchviewUploadName,
+            string[] scenarios,
+            string zipFileToDownload = "RoslynSolutions",
+            int zipFileVersion = 2) : base()
+        {
+            _testTemplateName = testTemplateName;
+            _testName = testName;
+            _zipFileToDownload = zipFileToDownload;
+            _zipFileVersion = zipFileVersion;
+            _solutionToTest = solutionToTest;
+            _benchviewUploadName = benchviewUploadName;
+            _scenarios = scenarios;
+            _logger = new ConsoleAndFileLogger();
+        }
+
+        public override void Setup()
+        {
+            // Download test zip
+            var dir = Path.Combine(Path.GetDirectoryName(MyWorkingDirectory), "csharp");
+            DownloadProject(_zipFileToDownload, version: _zipFileVersion, logger: _logger);
+
+            // Create log directory
+            var logDirectory = Path.Combine(TempDirectory, _testName);
+            Directory.CreateDirectory(logDirectory);
+            Directory.CreateDirectory(Path.Combine(logDirectory, "PerfResults"));
+
+            // Read the test template and replace with actual solution path.
+            var taoTestFileTemplatePath = Path.Combine(dir, _testTemplateName);
+            var template = File.ReadAllText(taoTestFileTemplatePath);
+            var finalTest = template.Replace("ReplaceWithActualSolutionPath", Path.Combine(TempDirectory, _zipFileToDownload, _solutionToTest));
+            finalTest = finalTest.Replace("ReplaceWithPerfLogDirectory", logDirectory);
+
+            // Perform test specific string replacements
+            finalTest = GetFinalTestSource(finalTest, dir);
+
+            // Write the final test into the test file.
+            File.WriteAllText(Path.Combine(TempDirectory, _testTemplateName), finalTest);
+
+            // Install Roslyn VSIXes into the perf hive.
+            InstallVsixes();
+        }
+
+        protected virtual string GetFinalTestSource(string testTemplateWithReplacedSolutionPath, string testFolderDirectory)
+            => testTemplateWithReplacedSolutionPath;
+
+        protected void InstallVsixes()
+        {
+            var vsix1 = Path.Combine(MyBinaries(), "Vsix", "VisualStudioSetup", "Roslyn.VisualStudio.Setup.vsix");
+            var vsix2 = Path.Combine(MyBinaries(), "Vsix", "VisualStudioSetup.Next", "Roslyn.VisualStudio.Setup.Next.vsix");
+
+            var rootSuffixArg = $"/rootsuffix:{_rootSuffix}";
+
+            // First uninstall any vsixes in the hive
+            ShellOutVital(_installerPath, $"{rootSuffixArg}, /uninstallAll");
+
+            // Then install the RoslynDeployment.vsix we just built
+            ShellOutVital(_installerPath, $"{rootSuffixArg} {vsix1}");
+            ShellOutVital(_installerPath, $"{rootSuffixArg} {vsix2}");
+        }
+
+        public override void Test()
+        {
+            var args = $"{Path.Combine(TempDirectory, _testTemplateName)} -perf -host:vs -roslynonly -rootsuffix:{_rootSuffix}";
+            ShellOutVital(TaoPath, args, TempDirectory);
+
+            var logDirectory = Path.Combine(TempDirectory, _testName, "PerfResults");
+            var xcopyArgs = $"{logDirectory} {Path.Combine(MyBinaries(), "..", "..", "ToArchive")} /s /i /y";
+            ShellOutVital("xcopy", xcopyArgs);
+
+            foreach (var xml in Directory.EnumerateFiles(logDirectory, "*.xml"))
+            {
+                Benchview.UploadBenchviewReport(xml, _benchviewUploadName);
+            }
+
+            _logger.Flush();
+        }
+
+        public override int Iterations => 1;
+        public override string Name => _testTemplateName.Substring(0, _testTemplateName.IndexOf("Template.xml"));
+        public override string MeasuredProc => "devenv";
+        public override bool ProvidesScenarios => false;
+        public override string[] GetScenarios()
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public override ITraceManager GetTraceManager()
+        {
+            return TraceManagerFactory.NoOpTraceManager();
+        }
+    }
+}
\ No newline at end of file

From a2e2bf45c31a7f91626017296d5e247631e92886 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Fri, 12 May 2017 19:03:32 -0700
Subject: [PATCH 159/284] Remove refout package moniker from build (#19469)

---
 build/Targets/Versions.props            | 2 --
 src/Tools/MicroBuild/publish-assets.ps1 | 1 -
 2 files changed, 3 deletions(-)

diff --git a/build/Targets/Versions.props b/build/Targets/Versions.props
index e4894bf9e12ff..3287c9342ed53 100644
--- a/build/Targets/Versions.props
+++ b/build/Targets/Versions.props
@@ -15,8 +15,6 @@
     <!-- The release moniker for our packages.  Developers should use "dev" and official builds pick the branch
          moniker listed below -->
     <RoslynNuGetMoniker Condition="'$(RoslynNuGetMoniker)' == ''">dev</RoslynNuGetMoniker>
-    <!-- PROTOTYPE(refout) This needs to be reverted before merging to master -->
-    <RoslynNuGetMoniker Condition="'$(OfficialBuild)' == 'true'">refout</RoslynNuGetMoniker>
     <!-- This is the base of the NuGet versioning for prerelease packages -->
     <NuGetPreReleaseVersion>$(RoslynFileVersionBase)-$(RoslynNuGetMoniker)</NuGetPreReleaseVersion>
 
diff --git a/src/Tools/MicroBuild/publish-assets.ps1 b/src/Tools/MicroBuild/publish-assets.ps1
index 61db51110d528..2d045b3c28228 100644
--- a/src/Tools/MicroBuild/publish-assets.ps1
+++ b/src/Tools/MicroBuild/publish-assets.ps1
@@ -43,7 +43,6 @@ try
         "dev15.3-preview1" { } 
         "master" { } 
         "post-dev15" { } 
-        "features/refout" { }
         default
         {
             if (-not $test)

From 02070e3ee807f0626a6f2045a2336be284cd98bb Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Tue, 2 May 2017 18:20:49 -0700
Subject: [PATCH 160/284] Reuse local rewriter to derive arguments for
 IHasArgumentsExpression

---
 .../CSharp/Portable/BoundTree/Expression.cs   | 108 ++++-
 .../Lowering/LocalRewriter/LocalRewriter.cs   |  14 +-
 .../LocalRewriter/LocalRewriter_Call.cs       | 416 ++++++++++++++----
 .../Lowering/SyntheticBoundNodeFactory.cs     |   6 +
 .../IOperation/IOperationTests_IArgument.cs   | 167 +++++--
 .../Utilities/CSharp/SemanticModelTestBase.cs |   2 +-
 6 files changed, 562 insertions(+), 151 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index d467ae27793e9..c35f69d53be41 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
@@ -59,7 +60,7 @@ internal partial class BoundCall : IInvocationExpression
             !this.ReceiverOpt.SuppressVirtualCalls;
 
         ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder
-            => DeriveArguments(this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Method.Parameters, this.Syntax);
+            => DeriveArguments(this, this.Method, this.Method, this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Method.Parameters, this.Expanded,  this.Syntax, this.InvokedAsExtensionMethod);
 
         protected override OperationKind ExpressionKind => OperationKind.InvocationExpression;
 
@@ -73,13 +74,97 @@ public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, T
             return visitor.VisitInvocationExpression(this, argument);
         }
 
+        private static readonly ConditionalWeakTable<BoundExpression, IEnumerable<IArgument>> s_callToArgumentsMappings 
+            = new ConditionalWeakTable<BoundExpression, IEnumerable<IArgument>>();
+
         // TODO: We need to reuse the logic in `LocalRewriter.MakeArguments` instead of using private implementation. 
         //       Also. this implementation here was for the (now removed) API `ArgumentsInParameter`, which doesn't fulfill
         //       the contract of `ArgumentsInEvaluationOrder` plus it doesn't handle various scenarios correctly even for parameter order, 
         //       e.g. default arguments, erroneous code, etc. 
         //       https://github.com/dotnet/roslyn/issues/18549
-        internal static ImmutableArray<IArgument> DeriveArguments(ImmutableArray<BoundExpression> boundArguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<int> argumentsToParametersOpt, ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<Symbols.ParameterSymbol> parameters, SyntaxNode invocationSyntax)
-        {
+        internal static ImmutableArray<IArgument> DeriveArguments(
+            BoundExpression boundNode,
+            Symbol methodOrIndexer,
+            MethodSymbol optionalParametersMethod,
+            ImmutableArray<BoundExpression> boundArguments,
+            ImmutableArray<string> argumentNamesOpt,
+            ImmutableArray<int> argumentsToParametersOpt,
+            ImmutableArray<RefKind> argumentRefKindsOpt,
+            ImmutableArray<ParameterSymbol> parameters,
+            bool expanded,
+            SyntaxNode invocationSyntax,
+            bool invokedAsExtensionMethod = false)
+        {
+            return (ImmutableArray<IArgument>) s_callToArgumentsMappings.GetValue(
+                boundNode, 
+                (n) =>
+                {
+                    //TODO: https://github.com/dotnet/roslyn/issues/18722
+                    //      Right now, for errornous code, we try to recover as much data as we can
+                    //      and expose them as IArguments, so user needs to check IsInvalid firdt before using 
+                    //      anything we returned. Need to implement a new interface for invalid invocation instead.
+                    if (n.HasErrors)
+                    {
+                        ArrayBuilder<IArgument> argumentsWithErrors = ArrayBuilder<IArgument>.GetInstance(boundArguments.Length);
+                        for (int a = 0; a < boundArguments.Length; a++)
+                        {
+                            var parameter = argumentsToParametersOpt.IsDefault
+                                            ? (a < parameters.Length
+                                                ? parameters[a]
+                                                : null)
+                                            : (argumentsToParametersOpt[a] > 0
+                                                ? parameters[argumentsToParametersOpt[a]]
+                                                : null);
+
+                            argumentsWithErrors.Add(new Argument(ArgumentKind.Explicit, parameter, boundArguments[a]));
+                        }
+
+                        return argumentsWithErrors.ToImmutableAndFree();
+                    }
+
+                    var diagnosticBag = new DiagnosticBag();
+                    var factory = new SyntheticBoundNodeFactory(invocationSyntax, diagnosticBag);
+                    var localRewriter = new LocalRewriter(
+                                            compilation: null,
+                                            containingMethod: null,
+                                            containingMethodOrdinal: 0,
+                                            rootStatement: null,
+                                            containingType: null,
+                                            factory: factory,
+                                            previousSubmissionFields: null,
+                                            allowOmissionOfConditionalCalls: false,
+                                            diagnostics: diagnosticBag,
+                                            instrumenter: null,
+                                            inOperationContext: true);
+
+                    var argumentKindBuilder = ArrayBuilder<ArgumentKind>.GetInstance(parameters.Length);
+                    var parameterSymbolBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameters.Length);
+
+                    var derivedArguments = localRewriter.MakeArguments(
+                        syntax: invocationSyntax,
+                        arguments: boundArguments,
+                        methodOrIndexer: methodOrIndexer,
+                        optionalParametersMethod: optionalParametersMethod,
+                        expanded: expanded,
+                        argsToParamsOpt: argumentsToParametersOpt,
+                        invokedAsExtensionMethod: invokedAsExtensionMethod,
+                        argumentKindBuilder: argumentKindBuilder,
+                        parameterSymbolBuilder: parameterSymbolBuilder);
+                    
+                    Debug.Assert(derivedArguments.Length == parameters.Length 
+                              && derivedArguments.Length == argumentKindBuilder.Count
+                              && derivedArguments.Length == parameterSymbolBuilder.Count);
+                    
+                    ArrayBuilder<IArgument> argumentsInEvaluationBuilder = ArrayBuilder<IArgument>.GetInstance(parameters.Length);
+                    for (int a = 0; a < derivedArguments.Length; a++)
+                    {
+                        argumentsInEvaluationBuilder.Add(new Argument(argumentKindBuilder[a], parameterSymbolBuilder[a], derivedArguments[a]));
+                    }
+
+                    return argumentsInEvaluationBuilder.ToImmutableAndFree();
+                });
+
+
             ArrayBuilder<IArgument> arguments = ArrayBuilder<IArgument>.GetInstance(boundArguments.Length);
             for (int parameterIndex = 0; parameterIndex < parameters.Length; parameterIndex++)
             {
@@ -355,7 +440,8 @@ internal partial class BoundIndexerAccess : IIndexedPropertyReferenceExpression
 
         ISymbol IMemberReferenceExpression.Member => this.Indexer;
 
-        ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder => BoundCall.DeriveArguments(this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Indexer.Parameters, this.Syntax);
+        ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder 
+            => BoundCall.DeriveArguments(this, this.Indexer, this.Indexer.GetOwnOrInheritedGetMethod(),this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Indexer.Parameters, this.Expanded, this.Syntax);
 
         protected override OperationKind ExpressionKind => OperationKind.IndexedPropertyReferenceExpression;
 
@@ -450,7 +536,16 @@ public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, T
 
     internal partial class BoundLiteral : ILiteralExpression
     {
-        string ILiteralExpression.Text => this.Syntax.ToString();
+        string ILiteralExpression.Text
+        {
+            get
+            {
+                object value;
+                return ((ILiteralExpression)this).ConstantValue.HasValue 
+                    ? ((value = this.ConstantValue.Value) == null ? "null" : value.ToString()) 
+                    : this.Syntax.ToString();
+            }
+        }
 
         protected override OperationKind ExpressionKind => OperationKind.LiteralExpression;
 
@@ -489,7 +584,8 @@ internal partial class BoundObjectCreationExpression : IObjectCreationExpression
 
         IMethodSymbol IObjectCreationExpression.Constructor => this.Constructor;
 
-        ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder => BoundCall.DeriveArguments(this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Constructor.Parameters, this.Syntax);
+        ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder 
+            => BoundCall.DeriveArguments(this, this.Constructor, this.Constructor, this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Constructor.Parameters, this.Expanded, this.Syntax);
 
         ImmutableArray<IOperation> IObjectCreationExpression.Initializers => GetChildInitializers(this.InitializerExpressionOpt).As<IOperation>();
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
index 3ef735c25087b..e87158d798d08 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
@@ -3,7 +3,6 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
-using System.Linq;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
@@ -30,9 +29,11 @@ internal sealed partial class LocalRewriter : BoundTreeRewriterWithStackGuard
         private readonly Instrumenter _instrumenter;
         private readonly BoundStatement _rootStatement;
 
+        private bool _inOperationContext;
+
         private Dictionary<BoundValuePlaceholderBase, BoundExpression> _placeholderReplacementMapDoNotUseDirectly;
 
-        private LocalRewriter(
+        internal LocalRewriter(
             CSharpCompilation compilation,
             MethodSymbol containingMethod,
             int containingMethodOrdinal,
@@ -42,20 +43,23 @@ private LocalRewriter(
             SynthesizedSubmissionFields previousSubmissionFields,
             bool allowOmissionOfConditionalCalls,
             DiagnosticBag diagnostics,
-            Instrumenter instrumenter)
+            Instrumenter instrumenter,
+            bool inOperationContext = false)
         {
             _compilation = compilation;
             _factory = factory;
             _factory.CurrentMethod = containingMethod;
-            Debug.Assert(factory.CurrentType == (containingType ?? containingMethod.ContainingType));
+            Debug.Assert(factory.CurrentType == (containingType ?? containingMethod?.ContainingType));
             _dynamicFactory = new LoweredDynamicOperationFactory(factory, containingMethodOrdinal);
             _previousSubmissionFields = previousSubmissionFields;
             _allowOmissionOfConditionalCalls = allowOmissionOfConditionalCalls;
             _diagnostics = diagnostics;
 
-            Debug.Assert(instrumenter != null);
+            Debug.Assert(instrumenter != null || inOperationContext);
             _instrumenter = instrumenter;
             _rootStatement = rootStatement;
+
+            _inOperationContext = inOperationContext;
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index 3ee96a545797e..a4421551f0b38 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -1,12 +1,13 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Semantics;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp
@@ -358,7 +359,7 @@ private static bool IsSafeForReordering(BoundExpression expression, RefKind kind
         /// itself. <paramref name="optionalParametersMethod"/> is needed for indexers since getter and setter
         /// may have distinct optional parameter values.
         /// </summary>
-        private ImmutableArray<BoundExpression> MakeArguments(
+        internal ImmutableArray<BoundExpression> MakeArguments(
             SyntaxNode syntax,
             ImmutableArray<BoundExpression> rewrittenArguments,
             Symbol methodOrIndexer,
@@ -370,6 +371,8 @@ private ImmutableArray<BoundExpression> MakeArguments(
             bool invokedAsExtensionMethod = false,
             ThreeState enableCallerInfo = ThreeState.Unknown)
         {
+            Debug.Assert(!_inOperationContext);
+
             // Either the methodOrIndexer is a property, in which case the method used
             // for optional parameters is an accessor of that property (or an overridden
             // property), or the methodOrIndexer is used for optional parameters directly.
@@ -385,38 +388,13 @@ private ImmutableArray<BoundExpression> MakeArguments(
             //
             // If none of those are the case then we can just take an early out.
 
-            // An applicable "vararg" method could not possibly be applicable in its expanded
-            // form, and cannot possibly have named arguments or used optional parameters, 
-            // because the __arglist() argument has to be positional and in the last position. 
-
-
-            if (methodOrIndexer.GetIsVararg())
-            {
-                Debug.Assert(rewrittenArguments.Length == methodOrIndexer.GetParameterCount() + 1);
-                Debug.Assert(argsToParamsOpt.IsDefault);
-                Debug.Assert(!expanded);
-                temps = default(ImmutableArray<LocalSymbol>);
-                return rewrittenArguments;
-            }
-
-            var receiverNamedType = invokedAsExtensionMethod ?
-                                    ((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol :
-                                    methodOrIndexer.ContainingType;
-
-            bool isComReceiver = (object)receiverNamedType != null && receiverNamedType.IsComImport;
-
-            ArrayBuilder<LocalSymbol> temporariesBuilder = ArrayBuilder<LocalSymbol>.GetInstance();
-            rewrittenArguments = _factory.MakeTempsForDiscardArguments(rewrittenArguments, temporariesBuilder);
-
-            if (rewrittenArguments.Length == methodOrIndexer.GetParameterCount() &&
-                argsToParamsOpt.IsDefault &&
-                !expanded &&
-                !isComReceiver)
+            if (TryReturnEarly(ref rewrittenArguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, out var isComReceiver, out var temporariesBuilder))
             {
-                temps = temporariesBuilder.ToImmutableAndFree();
+                temps = temporariesBuilder?.ToImmutableAndFree() ?? default(ImmutableArray<LocalSymbol>);
                 return rewrittenArguments;
             }
 
+            Debug.Assert(temporariesBuilder != null);
 
             // We have:
             // * a list of arguments, already converted to their proper types, 
@@ -512,6 +490,105 @@ private ImmutableArray<BoundExpression> MakeArguments(
             return actualArguments.AsImmutableOrNull();
         }
 
+        internal ImmutableArray<BoundExpression> MakeArguments(
+            SyntaxNode syntax,
+            ImmutableArray<BoundExpression> arguments,
+            Symbol methodOrIndexer,
+            MethodSymbol optionalParametersMethod,
+            bool expanded,
+            ImmutableArray<int> argsToParamsOpt,
+            bool invokedAsExtensionMethod,
+            /* out */ ArrayBuilder<ArgumentKind> argumentKindBuilder,
+            /* out */ ArrayBuilder<ParameterSymbol> parameterSymbolBuilder,
+            ThreeState enableCallerInfo = ThreeState.Unknown)
+        {
+            Debug.Assert(_inOperationContext && argumentKindBuilder.IsEmpty() && parameterSymbolBuilder.IsEmpty());
+
+            // Either the methodOrIndexer is a property, in which case the method used
+            // for optional parameters is an accessor of that property (or an overridden
+            // property), or the methodOrIndexer is used for optional parameters directly.
+            Debug.Assert(((methodOrIndexer.Kind == SymbolKind.Property) && optionalParametersMethod.IsAccessor()) ||
+                ReferenceEquals(methodOrIndexer, optionalParametersMethod));
+
+            // We need to do a fancy rewrite under the following circumstances:
+            // (1) a params array is being used; we need to generate the array.
+            // (2) there were named arguments that reordered the arguments; we might
+            //     have to generate temporaries to ensure that the arguments are 
+            //     evaluated in source code order, not the actual call order.
+            // (3) there were optional parameters that had no corresponding arguments.
+            //
+            // If none of those are the case then we can just take an early out.
+
+            ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters();
+
+            if (TryReturnEarly(ref arguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, out var isComReceiver, out var temporariesBuilder))
+            {
+                // In this case, the invocation is not in expanded form and there's no named argument provided.
+                // So we just return list of arguments as is.
+                for(int i = 0; i < arguments.Length; ++i)
+                {
+                    argumentKindBuilder.Add(ArgumentKind.Explicit);
+                    parameterSymbolBuilder.Add(parameters[i]);
+                }
+                return arguments;
+            }
+
+            Debug.Assert(temporariesBuilder == null);
+
+            ArrayBuilder<BoundExpression> argumentsBuilder = ArrayBuilder<BoundExpression>.GetInstance(parameters.Length);
+            ArrayBuilder<ParameterSymbol> missingParametersBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameters.Length);
+
+            BuildArgumentsInEvaluationOrder(syntax, methodOrIndexer, expanded, argsToParamsOpt, arguments, argumentsBuilder, argumentKindBuilder, parameterSymbolBuilder, missingParametersBuilder);
+
+            AppendMissingOptionalArguments(syntax, missingParametersBuilder.ToImmutableAndFree(), argumentsBuilder, argumentKindBuilder, parameterSymbolBuilder);
+
+            return argumentsBuilder.ToImmutableAndFree();
+        }
+
+        // temporariesBuilder will be null when _inOperationContext is true.
+        private bool TryReturnEarly(
+            ref ImmutableArray<BoundExpression> rewrittenArguments,
+            Symbol methodOrIndexer,
+            bool expanded,
+            ImmutableArray<int> argsToParamsOpt,
+            bool invokedAsExtensionMethod,
+            out bool isComReceiver,
+            out ArrayBuilder<LocalSymbol> temporariesBuilder)
+        {
+            temporariesBuilder = null;
+
+            // An applicable "vararg" method could not possibly be applicable in its expanded
+            // form, and cannot possibly have named arguments or used optional parameters, 
+            // because the __arglist() argument has to be positional and in the last position. 
+
+            if (methodOrIndexer.GetIsVararg())
+            {
+                Debug.Assert(rewrittenArguments.Length == methodOrIndexer.GetParameterCount() + 1);
+                Debug.Assert(argsToParamsOpt.IsDefault);
+                Debug.Assert(!expanded);
+                isComReceiver = false;
+                temporariesBuilder = null;
+                return true;
+            }
+
+            var receiverNamedType = invokedAsExtensionMethod ?
+                                    ((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol :
+                                    methodOrIndexer.ContainingType;
+
+            isComReceiver = (object)receiverNamedType != null && receiverNamedType.IsComImport;
+
+            if (!_inOperationContext)
+            {
+                temporariesBuilder = ArrayBuilder<LocalSymbol>.GetInstance();
+                rewrittenArguments = _factory.MakeTempsForDiscardArguments(rewrittenArguments, temporariesBuilder);
+            }
+
+            return rewrittenArguments.Length == methodOrIndexer.GetParameterCount() &&
+                argsToParamsOpt.IsDefault &&
+                !expanded &&
+                !isComReceiver;
+        }
+
         private static ImmutableArray<RefKind> GetRefKindsOrNull(ArrayBuilder<RefKind> refKinds)
         {
             foreach (var refKind in refKinds)
@@ -584,7 +661,7 @@ private void BuildStoresToTemps(
                     }
                 }
 
-                if (IsSafeForReordering(argument, refKind))
+                if (IsSafeForReordering(argument, refKind) || _inOperationContext)
                 {
                     arguments[p] = argument;
                     refKinds[p] = refKind;
@@ -599,6 +676,90 @@ private void BuildStoresToTemps(
             }
         }
 
+        // This fills in the arguments and parameters arrays in evaluation order.
+        private void BuildArgumentsInEvaluationOrder(
+            SyntaxNode syntax,
+            Symbol methodOrIndexer,
+            bool expanded,
+            ImmutableArray<int> argsToParamsOpt,
+            ImmutableArray<BoundExpression> arguments,
+            /* out */ ArrayBuilder<BoundExpression> argumentsBuilder,
+            /* out */ ArrayBuilder<ArgumentKind> argumentKindsBuilder,
+            /* out */ ArrayBuilder<ParameterSymbol> parametersBuilder,
+            /* out */ ArrayBuilder<ParameterSymbol> missingParametersBuilder)
+        {
+            ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters();
+            PooledHashSet<int> processedPeremeters = PooledHashSet<int>.GetInstance();
+
+            for (int a = 0; a < arguments.Length; ++a)
+            {
+                BoundExpression argument = arguments[a];
+
+                int p = (!argsToParamsOpt.IsDefault) ? argsToParamsOpt[a] : a;
+                var parameter = parameters[p];
+
+                bool processed = processedPeremeters.Add(p);
+                Debug.Assert(processed);
+
+                bool isParamArray = false;
+                if (expanded && p == parameters.Length - 1)
+                {
+                    isParamArray = true;
+
+                    ArrayBuilder<BoundExpression> paramArray = ArrayBuilder<BoundExpression>.GetInstance();
+                    paramArray.Add(argument);
+
+                    int remainingArgument = a + 1;
+                    for (; remainingArgument < arguments.Length; ++remainingArgument)
+                    {
+                        int remainingParameter = (!argsToParamsOpt.IsDefault) ? argsToParamsOpt[remainingArgument] : remainingArgument;
+                        if (remainingParameter != parameters.Length - 1)
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            paramArray.Add(arguments[remainingArgument]);
+                        }
+                    }
+                    // Set loop variable to index of the last processed argument.
+                    a = remainingArgument - 1;
+
+                    var paramArrayType = parameters[p].Type;
+                    var arrayArgs = paramArray.ToImmutableAndFree();
+
+                    argument = CreateParamArrayArgument(syntax, methodOrIndexer, paramArrayType, arrayArgs);
+                }
+
+                argumentsBuilder.Add(argument);
+                argumentKindsBuilder.Add(isParamArray ? ArgumentKind.ParamArray : ArgumentKind.Explicit);
+                parametersBuilder.Add(parameter);
+            }
+
+            // Create an empty array for omitted param array argument.
+            ParameterSymbol lastParameter;
+            if (expanded && (lastParameter = parameters.Last()).IsParams && !processedPeremeters.Contains(parameters.Length - 1))
+            {
+                var argument = CreateParamArrayArgument(syntax, methodOrIndexer, lastParameter.Type, ImmutableArray<BoundExpression>.Empty);
+
+                argumentsBuilder.Add(argument);
+                argumentKindsBuilder.Add(ArgumentKind.ParamArray);
+                parametersBuilder.Add(lastParameter);
+
+                processedPeremeters.Add(parameters.Length - 1);
+            }
+
+            // Fill in parameters with missing arguments.
+            for (int i = 0; i < parameters.Length; ++i)
+            {
+                if (!processedPeremeters.Contains(i))
+                {
+                    missingParametersBuilder.Add(parameters[i]);
+                }
+            }
+            processedPeremeters.Free();
+        }
+
         private BoundExpression BuildParamsArray(
             SyntaxNode syntax,
             Symbol methodOrIndexer,
@@ -632,12 +793,17 @@ private BoundExpression BuildParamsArray(
 
             var paramArrayType = parameters[paramsParam].Type;
             var arrayArgs = paramArray.ToImmutableAndFree();
+            return CreateParamArrayArgument(syntax, methodOrIndexer, paramArrayType, arrayArgs);
+        }
+
+        private BoundExpression CreateParamArrayArgument(SyntaxNode syntax, Symbol methodOrIndexer, TypeSymbol paramArrayType, ImmutableArray<BoundExpression> arrayArgs)
+        {
 
             // If this is a zero-length array, rather than using "new T[0]", optimize with "Array.Empty<T>()" 
             // if it's available.  However, we also disable the optimization if we're in an expression lambda, the 
             // point of which is just to represent the semantics of an operation, and we don't know that all consumers
             // of expression lambdas will appropriately understand Array.Empty<T>().
-            if (arrayArgs.Length == 0 && !_inExpressionLambda)
+            if (arrayArgs.Length == 0 && !_inExpressionLambda && !_inOperationContext)
             {
                 ArrayTypeSymbol ats = paramArrayType as ArrayTypeSymbol;
                 if (ats != null) // could be null if there's a semantic error, e.g. the params parameter type isn't an array
@@ -820,6 +986,25 @@ private void InsertMissingOptionalArguments(SyntaxNode syntax,
             }
         }
 
+        private void AppendMissingOptionalArguments(SyntaxNode syntax,
+            ImmutableArray<ParameterSymbol> missingParameters,
+            ArrayBuilder<BoundExpression> argumentsBuilder,
+            ArrayBuilder<ArgumentKind> argumentKindsBuilder,
+            ArrayBuilder<ParameterSymbol> parametersBuilder,
+            ThreeState enableCallerInfo = ThreeState.Unknown)
+        {
+            foreach (var parameter in missingParameters)
+            {
+                Debug.Assert(parameter.IsOptional);
+
+                var defaultArgument = GetDefaultParameterValue(syntax, parameter, enableCallerInfo);
+
+                argumentsBuilder.Add(defaultArgument);
+                argumentKindsBuilder.Add(ArgumentKind.DefaultValue);
+                parametersBuilder.Add(parameter);
+            }
+        }
+
         private static SourceLocation GetCallerLocation(SyntaxNode syntax, ThreeState enableCallerInfo)
         {
             switch (enableCallerInfo)
@@ -902,91 +1087,113 @@ private BoundExpression GetDefaultParameterValue(SyntaxNode syntax, ParameterSym
             if (parameter.IsCallerLineNumber && ((callerSourceLocation = GetCallerLocation(syntax, enableCallerInfo)) != null))
             {
                 int line = callerSourceLocation.SourceTree.GetDisplayLineNumber(callerSourceLocation.SourceSpan);
-                BoundExpression lineLiteral = MakeLiteral(syntax, ConstantValue.Create(line), _compilation.GetSpecialType(SpecialType.System_Int32));
 
-                if (parameterType.IsNullableType())
+                if (_inOperationContext)
                 {
-                    defaultValue = MakeConversionNode(lineLiteral, parameterType.GetNullableUnderlyingType(), false);
-
-                    // wrap it in a nullable ctor.
-                    defaultValue = new BoundObjectCreationExpression(
-                        syntax,
-                        UnsafeGetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
-                        defaultValue);
+                    defaultValue = MakeLiteral(syntax, ConstantValue.Create(line), parameter.ContainingAssembly.GetSpecialType(SpecialType.System_Int32));
                 }
                 else
                 {
-                    defaultValue = MakeConversionNode(lineLiteral, parameterType, false);
+                    BoundExpression lineLiteral = MakeLiteral(syntax, ConstantValue.Create(line), _compilation.GetSpecialType(SpecialType.System_Int32));
+
+                    if (parameterType.IsNullableType())
+                    {
+                        defaultValue = MakeConversionNode(lineLiteral, parameterType.GetNullableUnderlyingType(), false);
+
+                        // wrap it in a nullable ctor.
+                        defaultValue = new BoundObjectCreationExpression(
+                            syntax,
+                            UnsafeGetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
+                            defaultValue);
+                    }
+                    else
+                    {
+                        defaultValue = MakeConversionNode(lineLiteral, parameterType, false);
+                    }
                 }
             }
             else if (parameter.IsCallerFilePath && ((callerSourceLocation = GetCallerLocation(syntax, enableCallerInfo)) != null))
             {
-                string path = callerSourceLocation.SourceTree.GetDisplayPath(callerSourceLocation.SourceSpan, _compilation.Options.SourceReferenceResolver);
-                BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(path), _compilation.GetSpecialType(SpecialType.System_String));
-                defaultValue = MakeConversionNode(memberNameLiteral, parameterType, false);
+                if (_inOperationContext)
+                {
+                    string path = syntax.SyntaxTree.FilePath;
+                    defaultValue = MakeLiteral(syntax, ConstantValue.Create(path), parameter.ContainingAssembly.GetSpecialType(SpecialType.System_String));
+                }
+                else
+                {
+                    string path = callerSourceLocation.SourceTree.GetDisplayPath(callerSourceLocation.SourceSpan, _compilation.Options.SourceReferenceResolver);
+                    BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(path), _compilation.GetSpecialType(SpecialType.System_String));
+                    defaultValue = MakeConversionNode(memberNameLiteral, parameterType, false);
+                }
             }
             else if (parameter.IsCallerMemberName && ((callerSourceLocation = GetCallerLocation(syntax, enableCallerInfo)) != null))
             {
-                string memberName;
-
-                switch (_factory.TopLevelMethod.MethodKind)
+                if (_inOperationContext)
                 {
-                    case MethodKind.Constructor:
-                    case MethodKind.StaticConstructor:
-                        // See if the code is actually part of a field, field-like event or property initializer and return the name of the corresponding member.
-                        var memberDecl = syntax.Ancestors().OfType<MemberDeclarationSyntax>().FirstOrDefault();
-
-                        if (memberDecl != null)
-                        {
-                            BaseFieldDeclarationSyntax fieldDecl;
+                    defaultValue = MakeLiteral(syntax, ConstantValue.Create(string.Empty), parameter.ContainingAssembly.GetSpecialType(SpecialType.System_String));
+                }
+                else
+                {
+                    string memberName;
 
-                            if (memberDecl.Kind() == SyntaxKind.PropertyDeclaration)
-                            {
-                                var propDecl = (PropertyDeclarationSyntax)memberDecl;
-                                EqualsValueClauseSyntax initializer = propDecl.Initializer;
+                    switch (_factory.TopLevelMethod.MethodKind)
+                    {
+                        case MethodKind.Constructor:
+                        case MethodKind.StaticConstructor:
+                            // See if the code is actually part of a field, field-like event or property initializer and return the name of the corresponding member.
+                            var memberDecl = syntax.Ancestors().OfType<MemberDeclarationSyntax>().FirstOrDefault();
 
-                                if (initializer != null && initializer.Span.Contains(syntax.Span))
-                                {
-                                    memberName = propDecl.Identifier.ValueText;
-                                    break;
-                                }
-                            }
-                            else if ((fieldDecl = memberDecl as BaseFieldDeclarationSyntax) != null)
+                            if (memberDecl != null)
                             {
-                                memberName = null;
+                                BaseFieldDeclarationSyntax fieldDecl;
 
-                                foreach (VariableDeclaratorSyntax varDecl in fieldDecl.Declaration.Variables)
+                                if (memberDecl.Kind() == SyntaxKind.PropertyDeclaration)
                                 {
-                                    EqualsValueClauseSyntax initializer = varDecl.Initializer;
+                                    var propDecl = (PropertyDeclarationSyntax)memberDecl;
+                                    EqualsValueClauseSyntax initializer = propDecl.Initializer;
 
                                     if (initializer != null && initializer.Span.Contains(syntax.Span))
                                     {
-                                        memberName = varDecl.Identifier.ValueText;
+                                        memberName = propDecl.Identifier.ValueText;
                                         break;
                                     }
                                 }
-
-                                if (memberName != null)
+                                else if ((fieldDecl = memberDecl as BaseFieldDeclarationSyntax) != null)
                                 {
-                                    break;
+                                    memberName = null;
+
+                                    foreach (VariableDeclaratorSyntax varDecl in fieldDecl.Declaration.Variables)
+                                    {
+                                        EqualsValueClauseSyntax initializer = varDecl.Initializer;
+
+                                        if (initializer != null && initializer.Span.Contains(syntax.Span))
+                                        {
+                                            memberName = varDecl.Identifier.ValueText;
+                                            break;
+                                        }
+                                    }
+
+                                    if (memberName != null)
+                                    {
+                                        break;
+                                    }
                                 }
                             }
-                        }
 
-                        goto default;
+                            goto default;
 
-                    default:
-                        memberName = _factory.TopLevelMethod.GetMemberCallerName();
-                        break;
+                        default:
+                            memberName = _factory.TopLevelMethod.GetMemberCallerName();
+                            break;
+                    }
+                    BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(memberName), _compilation.GetSpecialType(SpecialType.System_String));
+                    defaultValue = MakeConversionNode(memberNameLiteral, parameterType, false);
                 }
-
-                BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(memberName), _compilation.GetSpecialType(SpecialType.System_String));
-                defaultValue = MakeConversionNode(memberNameLiteral, parameterType, false);
             }
             else if (defaultConstantValue == ConstantValue.NotAvailable)
             {
                 // There is no constant value given for the parameter in source/metadata.
-                if (parameterType.IsDynamic() || parameterType.SpecialType == SpecialType.System_Object)
+                if ((parameterType.IsDynamic() || parameterType.SpecialType == SpecialType.System_Object) && !_inOperationContext)
                 {
                     // We have something like M([Optional] object x). We have special handling for such situations.
                     defaultValue = GetDefaultParameterSpecial(syntax, parameter);
@@ -1008,19 +1215,27 @@ private BoundExpression GetDefaultParameterValue(SyntaxNode syntax, ParameterSym
                 // We have something like M(double? x = 1.23), so replace the argument
                 // with new double?(1.23).
 
-                TypeSymbol constantType = _compilation.GetSpecialType(defaultConstantValue.SpecialType);
-                defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType);
+                if (_inOperationContext)
+                {
+                    defaultValue = MakeLiteral(syntax, defaultConstantValue, parameterType);
+                }
+                else
+                {
+                    TypeSymbol constantType = _compilation.GetSpecialType(defaultConstantValue.SpecialType);
+                    defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType);
 
-                // The parameter's underlying type might not match the constant type. For example, we might have
-                // a default value of 5 (an integer) but a parameter type of decimal?.
+                    // The parameter's underlying type might not match the constant type. For example, we might have
+                    // a default value of 5 (an integer) but a parameter type of decimal?.
 
-                defaultValue = MakeConversionNode(defaultValue, parameterType.GetNullableUnderlyingType(), @checked: false, acceptFailingConversion: true);
+                    defaultValue = MakeConversionNode(defaultValue, parameterType.GetNullableUnderlyingType(), @checked: false, acceptFailingConversion: true);
 
-                // Finally, wrap it in a nullable ctor.
-                defaultValue = new BoundObjectCreationExpression(
-                    syntax,
-                    UnsafeGetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
-                    defaultValue);
+                    // Finally, wrap it in a nullable ctor.
+                    defaultValue = new BoundObjectCreationExpression(
+                        syntax,
+                        UnsafeGetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
+                        defaultValue);
+
+                }
             }
             else if (defaultConstantValue.IsNull || defaultConstantValue.IsBad)
             {
@@ -1030,10 +1245,17 @@ private BoundExpression GetDefaultParameterValue(SyntaxNode syntax, ParameterSym
             {
                 // We have something like M(double x = 1.23), so replace the argument with 1.23.
 
-                TypeSymbol constantType = _compilation.GetSpecialType(defaultConstantValue.SpecialType);
-                defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType);
-                // The parameter type might not match the constant type.
-                defaultValue = MakeConversionNode(defaultValue, parameterType, @checked: false, acceptFailingConversion: true);
+                if (_inOperationContext)
+                {
+                    defaultValue = MakeLiteral(syntax, defaultConstantValue, parameterType);
+                }
+                else
+                {
+                    TypeSymbol constantType = _compilation.GetSpecialType(defaultConstantValue.SpecialType);
+                    defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType);
+                    // The parameter type might not match the constant type.
+                    defaultValue = MakeConversionNode(defaultValue, parameterType, @checked: false, acceptFailingConversion: true);
+                }
             }
 
             return defaultValue;
diff --git a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
index 3f4fe16167ae4..26accb2f4553a 100644
--- a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
@@ -165,6 +165,12 @@ public SyntheticBoundNodeFactory(MethodSymbol topLevelMethodOpt, NamedTypeSymbol
             this.CurrentType = currentClassOpt;
             this.Syntax = node;
             this.Diagnostics = diagnostics;
+        }                                                                                
+
+        public SyntheticBoundNodeFactory(SyntaxNode node, DiagnosticBag diagnostics)
+        {                                          
+            this.Syntax = node;
+            this.Diagnostics = diagnostics;
         }
 
         [Conditional("DEBUG")]
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index e6a02e1a31ae1..9fdc714a5b091 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -27,14 +27,14 @@ static void M2(int x, double y) { }
   Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '1')
       ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
     IArgument (ArgumentKind.Explicit, Matching Parameter: y) (OperationKind.Argument) (Syntax: '2.0')
-      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Double, Constant: 2) (Syntax: '2.0')
+      ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Double, Constant: 2) (Syntax: '2.0')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void PositionalArgumentWithDefaultValue()
         {
             string source = @"
@@ -86,7 +86,7 @@ static void M2(int x, double y = 0.0) { }
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void NamedArgumentListedOutOfParameterOrder()
         {
             string source = @"
@@ -111,8 +111,7 @@ static void M2(int x, double y = 0.0) { }
 
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
-
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        
         public void NamedArgumentInParameterOrderWithDefaultValue()
         {
             string source = @"
@@ -139,8 +138,8 @@ static void M2(int x = 1, int y = 2, int z = 3) { }
 
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
-
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        
+        [Fact]
         public void NamedArgumentOutOfParameterOrderWithDefaultValue()
         {
             string source = @"
@@ -168,7 +167,7 @@ static void M2(int x = 1, int y = 2, int z = 3) { }
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void NamedAndPositionalArgumentsWithDefaultValue()
         {
             string source = @"
@@ -255,7 +254,7 @@ void M1()
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void NamedRefAndOutArgumentsOutOfParameterOrder()
         {
             string source = @"
@@ -271,13 +270,20 @@ void M1()
     void M2(ref int x, out int y) { y = 10; }
 }
 ";
-            string expectedOperationTree = @"";
+            string expectedOperationTree = @"
+IInvocationExpression ( void P.M2(ref System.Int32 x, out System.Int32 y)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'M2(y: out b, x: ref a)')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
+  Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: y) (OperationKind.Argument) (Syntax: 'b')
+      ILocalReferenceExpression: b (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'b')
+    IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: 'a')
+      ILocalReferenceExpression: a (OperationKind.LocalReferenceExpression, Type: System.Int32) (Syntax: 'a')
+";
             var expectedDiagnostics = DiagnosticDescription.None;
 
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void DefaultValueOfNewStruct()
         {
             string source = @"
@@ -293,13 +299,18 @@ void M1()
 
 struct S { }
 ";
-            string expectedOperationTree = @"";
+            string expectedOperationTree = @"
+IInvocationExpression ( void P.M2([S sobj = default(S)])) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'M2()')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
+  Arguments(1): IArgument (ArgumentKind.DefaultValue, Matching Parameter: sobj) (OperationKind.Argument) (Syntax: 'M2()')
+      IDefaultValueExpression (OperationKind.DefaultValueExpression, Type: S) (Syntax: 'M2()')
+";
             var expectedDiagnostics = DiagnosticDescription.None;
 
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void DefaultValueOfDefaultStruct()
         {
             string source = @"
@@ -315,13 +326,18 @@ void M1()
 
 struct S { }
 ";
-            string expectedOperationTree = @"";
+            string expectedOperationTree = @"
+IInvocationExpression ( void P.M2([S sobj = default(S)])) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'M2()')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
+  Arguments(1): IArgument (ArgumentKind.DefaultValue, Matching Parameter: sobj) (OperationKind.Argument) (Syntax: 'M2()')
+      IDefaultValueExpression (OperationKind.DefaultValueExpression, Type: S) (Syntax: 'M2()')
+";
             var expectedDiagnostics = DiagnosticDescription.None;
 
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void DefaultValueOfConstant()
         {
             string source = @"
@@ -379,7 +395,7 @@ public static void E1(this P p, int x = 0, int y = 0)
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void NamedArgumentOutOfParameterOrderForExtensionMethod()
         {
             string source = @"
@@ -412,7 +428,7 @@ public static void E1(this P p, int x = 0, int y = 0)
             VerifyOperationTreeAndDiagnosticsForTest<ExpressionStatementSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void NamedArgumentWithDefaultValueForExtensionMethod()
         {
             string source = @"
@@ -491,10 +507,10 @@ void M2(int x, params double[] array) { }
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
   Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '1')
       ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
-    IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: '0.1')
-      IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: '0.1')
-        Dimension Sizes(1): ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: null, Constant: 2) (Syntax: '0.1')
-        Initializer: IArrayInitializer (2 elements) (OperationKind.ArrayInitializer) (Syntax: '0.1')
+    IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: 'M2(1, 0.1, 0.2)')
+      IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: 'M2(1, 0.1, 0.2)')
+        Dimension Sizes(1): ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: 'M2(1, 0.1, 0.2)')
+        Initializer: IArrayInitializer (2 elements) (OperationKind.ArrayInitializer) (Syntax: 'M2(1, 0.1, 0.2)')
             Element Values(2): ILiteralExpression (Text: 0.1) (OperationKind.LiteralExpression, Type: System.Double, Constant: 0.1) (Syntax: '0.1')
               ILiteralExpression (Text: 0.2) (OperationKind.LiteralExpression, Type: System.Double, Constant: 0.2) (Syntax: '0.2')
 ";
@@ -503,7 +519,7 @@ Element Values(2): ILiteralExpression (Text: 0.1) (OperationKind.LiteralExpressi
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void ParamsArrayArgumentInExpandedFormWithNoArgument()
         {
             string source = @"
@@ -524,15 +540,15 @@ void M2(int x, params double[] array) { }
       ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
     IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: 'M2(1)')
       IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: 'M2(1)')
-        Dimension Sizes(1): ILiteralExpression (Text: 0) (OperationKind.LiteralExpression, Type: null, Constant: 0) (Syntax: 'M2(1)')
-        Initializer: IArrayInitializer (OperationKind.ArrayInitializer) (Syntax: 'M2(1)')
+        Dimension Sizes(1): ILiteralExpression (Text: 0) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: 'M2(1)')
+        Initializer: IArrayInitializer (0 elements) (OperationKind.ArrayInitializer) (Syntax: 'M2(1)')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void DefaultValueAndParamsArrayArgumentInExpandedFormWithNoArgument()
         {
             string source = @"
@@ -562,7 +578,7 @@ Dimension Sizes(1): ILiteralExpression (Text: 0) (OperationKind.LiteralExpressio
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void DefaultValueAndNamedParamsArrayArgumentInNormalForm()
         {
             string source = @"
@@ -590,7 +606,7 @@ void M2(int x = 0, params double[] array) { }
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void DefaultValueAndNamedParamsArrayArgumentInExpandedForm()
         {
             string source = @"
@@ -607,10 +623,10 @@ void M2(int x = 0, params double[] array) { }
             string expectedOperationTree = @"
 IInvocationExpression ( void P.M2([System.Int32 x = 0], params System.Double[] array)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'M2(array: 1)')
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
-  Arguments(2): IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: '1')
-      IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: '1')
-        Dimension Sizes(1): ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: null, Constant: 1) (Syntax: '1')
-        Initializer: IArrayInitializer (OperationKind.ArrayInitializer) (Syntax: '1')
+  Arguments(2): IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: 'M2(array: 1)')
+      IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: 'M2(array: 1)')
+        Dimension Sizes(1): ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: 'M2(array: 1)')
+        Initializer: IArrayInitializer (1 elements) (OperationKind.ArrayInitializer) (Syntax: 'M2(array: 1)')
             Element Values(1): IConversionExpression (ConversionKind.CSharp, Implicit) (OperationKind.ConversionExpression, Type: System.Double, Constant: 1) (Syntax: '1')
                 ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
     IArgument (ArgumentKind.DefaultValue, Matching Parameter: x) (OperationKind.Argument) (Syntax: 'M2(array: 1)')
@@ -649,7 +665,7 @@ void M2(int x = 0, params double[] array) { }
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void PositionalArgumentAndNamedParamsArrayArgumentInExpandedForm()
         {
             string source = @"
@@ -668,10 +684,10 @@ void M2(int x = 0, params double[] array) { }
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
   Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '1')
       ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
-    IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: '1')
-      IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: '1')
-        Dimension Sizes(1): ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: null, Constant: 1) (Syntax: '1')
-        Initializer: IArrayInitializer (OperationKind.ArrayInitializer) (Syntax: '1')
+    IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: 'M2(1, array: 1)')
+      IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: 'M2(1, array: 1)')
+        Dimension Sizes(1): ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: 'M2(1, array: 1)')
+        Initializer: IArrayInitializer (1 elements) (OperationKind.ArrayInitializer) (Syntax: 'M2(1, array: 1)')
             Element Values(1): IConversionExpression (ConversionKind.CSharp, Implicit) (OperationKind.ConversionExpression, Type: System.Double, Constant: 1) (Syntax: '1')
                 ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
 ";
@@ -680,7 +696,7 @@ Element Values(1): IConversionExpression (ConversionKind.CSharp, Implicit) (Oper
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void NamedArgumentAndNamedParamsArrayArgumentInNormalFormOutOfParameterOrder()
         {
             string source = @"
@@ -709,7 +725,7 @@ void M2(int x = 0, params double[] array) { }
             VerifyOperationTreeAndDiagnosticsForTest<ExpressionStatementSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void NamedArgumentAndNamedParamsArrayArgumentInExpandedFormOutOfParameterOrder()
         {
             string source = @"
@@ -726,10 +742,10 @@ void M2(int x = 0, params double[] array) { }
             string expectedOperationTree = @"
 IInvocationExpression ( void P.M2([System.Int32 x = 0], params System.Double[] array)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'M2(array: 1, x: 10)')
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
-  Arguments(2): IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: '1')
-      IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: '1')
-        Dimension Sizes(1): ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: null, Constant: 1) (Syntax: '1')
-        Initializer: IArrayInitializer (OperationKind.ArrayInitializer) (Syntax: '1')
+  Arguments(2): IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: 'M2(array: 1, x: 10)')
+      IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: 'M2(array: 1, x: 10)')
+        Dimension Sizes(1): ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: 'M2(array: 1, x: 10)')
+        Initializer: IArrayInitializer (1 elements) (OperationKind.ArrayInitializer) (Syntax: 'M2(array: 1, x: 10)')
             Element Values(1): IConversionExpression (ConversionKind.CSharp, Implicit) (OperationKind.ConversionExpression, Type: System.Double, Constant: 1) (Syntax: '1')
                 ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
     IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '10')
@@ -739,5 +755,72 @@ Element Values(1): IConversionExpression (ConversionKind.CSharp, Implicit) (Oper
 
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
+
+        [Fact]
+        public void CallerInfoAttributes()
+        {
+            string source = @"
+using System.Runtime.CompilerServices;
+
+class P
+{
+    void M1()
+    {
+        /*<bind>*/M2()/*</bind>*/;
+    }
+
+    void M2(
+        [CallerMemberName] string memberName = null,
+        [CallerFilePath] string sourceFilePath = null,
+        [CallerLineNumber] int sourceLineNumber = 0)
+    { }
+}
+";
+            string expectedOperationTree = @"
+IInvocationExpression ( void P.M2([System.String memberName = null], [System.String sourceFilePath = null], [System.Int32 sourceLineNumber = 0])) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'M2()')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
+  Arguments(3): IArgument (ArgumentKind.DefaultValue, Matching Parameter: memberName) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (Text: ) (OperationKind.LiteralExpression, Type: System.String, Constant: """") (Syntax: 'M2()')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceFilePath) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (Text: ) (OperationKind.LiteralExpression, Type: System.String, Constant: """") (Syntax: 'M2()')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceLineNumber) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (Text: 8) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 8) (Syntax: 'M2()')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [Fact]
+        public void ExtraArgument()
+        {
+            string source = @"
+class P
+{
+    void M1()
+    {
+        /*<bind>*/M2(1, 2)/*</bind>*/;
+    }
+
+    void M2(int x = 0)
+    { }
+}
+";
+            string expectedOperationTree = @"
+IInvocationExpression ( void P.M2([System.Int32 x = 0])) (OperationKind.InvocationExpression, Type: System.Void, IsInvalid) (Syntax: 'M2(1, 2)')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
+  Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '1')
+      ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
+    IArgument (ArgumentKind.Explicit, Matching Parameter: null) (OperationKind.Argument, IsInvalid) (Syntax: '2')
+      ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: '2')
+";
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS1501: No overload for method 'M2' takes 2 arguments
+                //         /*<bind>*/M2(1, 2)/*</bind>*/;
+                Diagnostic(ErrorCode.ERR_BadArgCount, "M2").WithArguments("M2", "2").WithLocation(6, 19)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
index 0dee845d82b18..f314880a484b5 100644
--- a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
@@ -268,7 +268,7 @@ protected void VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(CSharpCompi
         protected void VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(string testSrc, string expectedOperationTree, DiagnosticDescription[] expectedDiagnostics, CSharpCompilationOptions compilationOptions = null, CSharpParseOptions parseOptions = null)
             where TSyntaxNode : SyntaxNode
         {
-            var compilation = CreateStandardCompilation(testSrc, new[] { SystemCoreRef, ValueTupleRef, SystemRuntimeFacadeRef }, options: compilationOptions ?? TestOptions.ReleaseDll, parseOptions: parseOptions);
+            var compilation = CreateCompilationWithMscorlib45(testSrc, options: compilationOptions ?? TestOptions.ReleaseDll, parseOptions: parseOptions);
             VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(compilation, expectedOperationTree, expectedDiagnostics);
         }
     }

From b6fe1b5aff26d8fec88d66a5eece07bbc3f6fa46 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Wed, 3 May 2017 18:32:43 -0700
Subject: [PATCH 161/284] Remove unused code

---
 .../CSharp/Portable/BoundTree/Expression.cs   | 173 +-----------------
 1 file changed, 4 insertions(+), 169 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index c35f69d53be41..4e593d5482120 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -163,162 +163,17 @@ internal static ImmutableArray<IArgument> DeriveArguments(
 
                     return argumentsInEvaluationBuilder.ToImmutableAndFree();
                 });
-
-
-            ArrayBuilder<IArgument> arguments = ArrayBuilder<IArgument>.GetInstance(boundArguments.Length);
-            for (int parameterIndex = 0; parameterIndex < parameters.Length; parameterIndex++)
-            {
-                int argumentIndex = -1;
-                if (argumentsToParametersOpt.IsDefault)
-                {
-                    argumentIndex = parameterIndex;
-                }
-                else
-                {
-                    argumentIndex = argumentsToParametersOpt.IndexOf(parameterIndex);
-                }
-
-                if ((uint)argumentIndex >= (uint)boundArguments.Length)
-                {
-                    // No argument has been supplied for the parameter at `parameterIndex`:
-                    // 1. `argumentIndex == -1' when the arguments are specified out of parameter order, and no argument is provided for parameter corresponding to `parameters[parameterIndex]`.
-                    // 2. `argumentIndex >= boundArguments.Length` when the arguments are specified in parameter order, and no argument is provided at `parameterIndex`.
-
-                    Symbols.ParameterSymbol parameter = parameters[parameterIndex];
-                    if (parameter.HasExplicitDefaultValue)
-                    {
-                        // The parameter is optional with a default value.
-                        arguments.Add(new Argument(ArgumentKind.DefaultValue, parameter, new LiteralExpression(parameter.ExplicitDefaultConstantValue, parameter.Type, invocationSyntax)));
-                    }
-                    else
-                    {
-                        // If the invocation is semantically valid, the parameter will be a params array and an empty array will be provided.
-                        // If the argument is otherwise omitted for a parameter with no default value, the invocation is not valid and a null argument will be provided.
-                        arguments.Add(DeriveArgument(parameterIndex, boundArguments.Length, boundArguments, argumentNamesOpt, argumentRefKindsOpt, parameters, invocationSyntax));
-                    }
-                }
-                else
-                {
-                    arguments.Add(DeriveArgument(parameterIndex, argumentIndex, boundArguments, argumentNamesOpt, argumentRefKindsOpt, parameters, invocationSyntax));
-                }
-            }
-
-            return arguments.ToImmutableAndFree();
         }
 
-        private static readonly ConditionalWeakTable<BoundExpression, IArgument> s_argumentMappings = new ConditionalWeakTable<BoundExpression, IArgument>();
-
-        private static IArgument DeriveArgument(int parameterIndex, int argumentIndex, ImmutableArray<BoundExpression> boundArguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<Symbols.ParameterSymbol> parameters, SyntaxNode invocationSyntax)
+        private class Argument : IArgument
         {
-            if ((uint)argumentIndex >= (uint)boundArguments.Length)
-            {
-                // Check for an omitted argument that becomes an empty params array.
-                if (parameters.Length > 0)
-                {
-                    Symbols.ParameterSymbol lastParameter = parameters[parameters.Length - 1];
-                    if (lastParameter.IsParams)
-                    {
-                        return new Argument(ArgumentKind.ParamArray, lastParameter, CreateParamArray(lastParameter, boundArguments, argumentIndex, invocationSyntax));
-                    }
-                }
-
-                // There is no supplied argument and there is no params parameter. Any action is suspect at this point.
-                return new SimpleArgument(null, new InvalidExpression(invocationSyntax, ImmutableArray<IOperation>.Empty));
-            }
-
-            return s_argumentMappings.GetValue(
-                boundArguments[argumentIndex],
-                (argument) =>
-                {
-                    string nameOpt = !argumentNamesOpt.IsDefaultOrEmpty ? argumentNamesOpt[argumentIndex] : null;
-                    Symbols.ParameterSymbol parameterOpt = (uint)parameterIndex < (uint)parameters.Length ? parameters[parameterIndex] : null;
-
-                    if ((object)nameOpt == null)
-                    {
-                        RefKind refMode = argumentRefKindsOpt.IsDefaultOrEmpty ? RefKind.None : argumentRefKindsOpt[argumentIndex];
-
-                        if (refMode != RefKind.None)
-                        {
-                            return new Argument(ArgumentKind.Explicit, parameterOpt, argument);
-                        }
-
-                        if (argumentIndex >= parameters.Length - 1 &&
-                            parameters.Length > 0 &&
-                            parameters[parameters.Length - 1].IsParams &&
-                            // An argument that is an array of the appropriate type is not a params argument.
-                            (boundArguments.Length > argumentIndex + 1 ||
-                             ((object)argument.Type != null && // If argument type is null, we are in an error scenario and cannot tell if it is a param array, or not. 
-                              (argument.Type.TypeKind != TypeKind.Array ||
-                              !argument.Type.Equals(parameters[parameters.Length - 1].Type, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)))))
-                        {
-                            return new Argument(ArgumentKind.ParamArray, parameters[parameters.Length - 1], CreateParamArray(parameters[parameters.Length - 1], boundArguments, argumentIndex, invocationSyntax));
-                        }
-                        else
-                        {
-                            return new SimpleArgument(parameterOpt, argument);
-                        }
-                    }
-
-                    return new Argument(ArgumentKind.Explicit, parameterOpt, argument);
-                });
-        }
-
-        private static IOperation CreateParamArray(IParameterSymbol parameter, ImmutableArray<BoundExpression> boundArguments, int firstArgumentElementIndex, SyntaxNode invocationSyntax)
-        {
-            if (parameter.Type.TypeKind == TypeKind.Array)
-            {
-                IArrayTypeSymbol arrayType = (IArrayTypeSymbol)parameter.Type;
-                ArrayBuilder<IOperation> builder = ArrayBuilder<IOperation>.GetInstance(boundArguments.Length - firstArgumentElementIndex);
-                for (int index = firstArgumentElementIndex; index < boundArguments.Length; index++)
-                {
-                    builder.Add(boundArguments[index]);
-                }
-
-                var paramArrayArguments = builder.ToImmutableAndFree();
-
-
-                // Use the invocation syntax node if there is no actual syntax available for the argument (because the paramarray is empty.)
-                return new ArrayCreationExpression(arrayType, paramArrayArguments, paramArrayArguments.Length > 0 ? paramArrayArguments[0].Syntax : invocationSyntax);
-            }
-
-            return new InvalidExpression(invocationSyntax, ImmutableArray<IOperation>.Empty);
-        }
-
-        internal static IArgument ArgumentMatchingParameter(ImmutableArray<BoundExpression> arguments, ImmutableArray<int> argumentsToParametersOpt, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, ISymbol targetMethod, ImmutableArray<Symbols.ParameterSymbol> parameters, IParameterSymbol parameter, SyntaxNode invocationSyntax)
-        {
-            int argumentIndex = ArgumentIndexMatchingParameter(argumentsToParametersOpt, targetMethod, parameter);
-            if (argumentIndex >= 0)
-            {
-                return DeriveArgument(parameter.Ordinal, argumentIndex, arguments, argumentNamesOpt, argumentRefKindsOpt, parameters, invocationSyntax);
-            }
-
-            return null;
-        }
-
-        private static int ArgumentIndexMatchingParameter(ImmutableArray<int> argumentsToParametersOpt, ISymbol targetMethod, IParameterSymbol parameter)
-        {
-            if (parameter.ContainingSymbol == targetMethod)
-            {
-                int parameterIndex = parameter.Ordinal;
-                if (!argumentsToParametersOpt.IsDefaultOrEmpty)
-                {
-                    return argumentsToParametersOpt.IndexOf(parameterIndex);
-                }
-
-                return parameterIndex;
-            }
-
-            return -1;
-        }
-
-        private abstract class ArgumentBase : IArgument
-        {
-            public ArgumentBase(IParameterSymbol parameter, IOperation value)
+            public Argument(ArgumentKind kind, IParameterSymbol parameter, IOperation value)
             {
                 Debug.Assert(value != null);
 
                 this.Value = value;
                 this.Parameter = parameter;
+                this.ArgumentKind = kind;
             }
 
             public IParameterSymbol Parameter { get; }
@@ -339,7 +194,7 @@ public ArgumentBase(IParameterSymbol parameter, IOperation value)
 
             public Optional<object> ConstantValue => default(Optional<object>);
 
-            public abstract ArgumentKind ArgumentKind { get; }
+            public ArgumentKind ArgumentKind { get; }
 
             void IOperation.Accept(OperationVisitor visitor)
             {
@@ -351,26 +206,6 @@ TResult IOperation.Accept<TArgument, TResult>(OperationVisitor<TArgument, TResul
                 return visitor.VisitArgument(this, argument);
             }
         }
-
-        private sealed class SimpleArgument : ArgumentBase
-        {
-            public SimpleArgument(IParameterSymbol parameter, IOperation value)
-                : base(parameter, value)
-            { }
-
-            public override ArgumentKind ArgumentKind => ArgumentKind.Explicit;
-        }
-
-        private sealed class Argument : ArgumentBase
-        {
-            public Argument(ArgumentKind kind, IParameterSymbol parameter, IOperation value)
-                : base(parameter, value)
-            {
-                this.ArgumentKind = kind;
-            }
-
-            public override ArgumentKind ArgumentKind { get; }
-        }
     }
 
     internal partial class BoundLocal : ILocalReferenceExpression

From e4844dd7a87bf6331c88fb5c5694df36a074d70f Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Fri, 5 May 2017 15:41:19 -0700
Subject: [PATCH 162/284] Add binder to BoundCall, BoundIndexerAccess and
 BoundObjectCreationExpression

For IOperation purposes
---
 .../Portable/Binder/Binder_Expressions.cs     |  5 ++-
 .../Portable/Binder/Binder_Invocation.cs      |  8 ++--
 .../CSharp/Portable/Binder/Binder_Query.cs    |  2 +-
 .../Portable/BoundTree/BoundExpression.cs     |  1 +
 .../CSharp/Portable/BoundTree/BoundNodes.xml  |  3 ++
 .../BoundObjectCreationExpression.cs          |  8 ++--
 .../CSharp/Portable/BoundTree/Constructors.cs | 17 ++++----
 .../CSharp/Portable/BoundTree/Expression.cs   | 13 +++---
 .../CSharp/Portable/CodeGen/Optimizer.cs      |  4 +-
 .../Compiler/MethodBodySynthesizer.cs         |  1 +
 .../Portable/Compiler/MethodCompiler.cs       |  1 +
 .../Generated/BoundNodes.xml.Generated.cs     | 42 ++++++++++++-------
 .../AsyncRewriter/AwaitExpressionSpiller.cs   |  2 +-
 .../Lowering/LambdaRewriter/LambdaRewriter.cs |  1 +
 .../LocalRewriter_AnonymousObjectCreation.cs  |  1 +
 .../LocalRewriter_BinaryOperator.cs           |  2 +
 .../LocalRewriter/LocalRewriter_Call.cs       | 10 ++++-
 ...ocalRewriter_CompoundAssignmentOperator.cs |  1 +
 .../LocalRewriter/LocalRewriter_Conversion.cs |  6 ++-
 .../LocalRewriter_IndexerAccess.cs            |  4 +-
 .../LocalRewriter/LocalRewriter_Literal.cs    |  4 +-
 .../LocalRewriter_ObjectCreationExpression.cs |  1 +
 .../LocalRewriter_TupleCreationExpression.cs  |  7 ++--
 .../LocalRewriter_UnaryOperator.cs            |  7 ++--
 .../Lowering/MethodToClassRewriter.cs         |  2 +
 .../Lowering/SyntheticBoundNodeFactory.cs     |  6 +--
 .../SynthesizedEntryPointSymbol.cs            |  5 ++-
 27 files changed, 103 insertions(+), 61 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
index 7b3587c586de9..2b9452c975350 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
@@ -3431,6 +3431,7 @@ private BoundExpression BindConstructorInitializerCore(
                         invokedAsExtensionMethod: false,
                         argsToParamsOpt: memberResolutionResult.Result.ArgsToParamsOpt,
                         resultKind: LookupResultKind.Viable,
+                        binderOpt: this,
                         type: constructorReturnType,
                         hasErrors: hasErrors)
                     { WasCompilerGenerated = initializerArgumentListOpt == null };
@@ -4524,6 +4525,7 @@ protected BoundExpression BindClassCreationExpression(
                     memberResolutionResult.Result.ArgsToParamsOpt,
                     constantValueOpt,
                     boundInitializerOpt,
+                    this,
                     type,
                     hasError);
 
@@ -4663,7 +4665,7 @@ private BoundExpression BindComImportCoClassCreationExpression(ObjectCreationExp
                         var creation = (BoundObjectCreationExpression)classCreation;
                         return creation.Update(creation.Constructor, creation.ConstructorsGroup, creation.Arguments, creation.ArgumentNamesOpt,
                                                creation.ArgumentRefKindsOpt, creation.Expanded, creation.ArgsToParamsOpt, creation.ConstantValueOpt,
-                                               creation.InitializerExpressionOpt, interfaceType);
+                                               creation.InitializerExpressionOpt, creation.BinderOpt, interfaceType);
 
                     case BoundKind.BadExpression:
                         var bad = (BoundBadExpression)classCreation;
@@ -6827,6 +6829,7 @@ private BoundExpression BindIndexerOrIndexedPropertyAccess(
                     argumentRefKinds,
                     isExpanded,
                     argsToParams,
+                    this,
                     property.Type,
                     gotError);
             }
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs
index 01444f1e0d683..19d872a4142fd 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs
@@ -982,7 +982,7 @@ private BoundCall BindInvocationExpressionContinued(
             {
                 return new BoundCall(node, receiver, method, args, argNames, argRefKinds, isDelegateCall: true,
                             expanded: expanded, invokedAsExtensionMethod: invokedAsExtensionMethod,
-                            argsToParamsOpt: argsToParams, resultKind: LookupResultKind.Viable, type: returnType, hasErrors: gotError);
+                            argsToParamsOpt: argsToParams, resultKind: LookupResultKind.Viable, binderOpt: this, type: returnType, hasErrors: gotError);
             }
             else
             {
@@ -1003,7 +1003,7 @@ private BoundCall BindInvocationExpressionContinued(
 
                 return new BoundCall(node, receiver, method, args, argNames, argRefKinds, isDelegateCall: false,
                             expanded: expanded, invokedAsExtensionMethod: invokedAsExtensionMethod,
-                            argsToParamsOpt: argsToParams, resultKind: LookupResultKind.Viable, type: returnType, hasErrors: gotError);
+                            argsToParamsOpt: argsToParams, resultKind: LookupResultKind.Viable, binderOpt: this, type: returnType, hasErrors: gotError);
             }
         }
 
@@ -1124,7 +1124,7 @@ private BoundCall CreateBadCall(
             args = BuildArgumentsForErrorRecovery(analyzedArguments, methods);
             var argNames = analyzedArguments.GetNames();
             var argRefKinds = analyzedArguments.RefKinds.ToImmutableOrNull();
-            return BoundCall.ErrorCall(node, receiver, method, args, argNames, argRefKinds, isDelegate, invokedAsExtensionMethod: invokedAsExtensionMethod, originalMethods: methods, resultKind: resultKind);
+            return BoundCall.ErrorCall(node, receiver, method, args, argNames, argRefKinds, isDelegate, invokedAsExtensionMethod: invokedAsExtensionMethod, originalMethods: methods, resultKind: resultKind, binder: this);
         }
 
         private static bool IsUnboundGeneric(MethodSymbol method)
@@ -1330,7 +1330,7 @@ private BoundCall CreateBadCall(
             var argRefKinds = analyzedArguments.RefKinds.ToImmutableOrNull();
             var originalMethods = (expr.Kind == BoundKind.MethodGroup) ? ((BoundMethodGroup)expr).Methods : ImmutableArray<MethodSymbol>.Empty;
 
-            return BoundCall.ErrorCall(node, expr, method, args, argNames, argRefKinds, isDelegateCall: false, invokedAsExtensionMethod: false, originalMethods: originalMethods, resultKind: resultKind);
+            return BoundCall.ErrorCall(node, expr, method, args, argNames, argRefKinds, isDelegateCall: false, invokedAsExtensionMethod: false, originalMethods: originalMethods, resultKind: resultKind, binder: this);
         }
 
         private static TypeSymbol GetCommonTypeOrReturnType<TMember>(ImmutableArray<TMember> members)
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Query.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Query.cs
index 7a540dfa613b3..6267ce3077e6e 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Query.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Query.cs
@@ -224,7 +224,7 @@ private static BoundCall ReverseLastTwoParameterOrder(BoundCall result)
             return result.Update(
                 result.ReceiverOpt, result.Method, arguments.ToImmutableAndFree(), default(ImmutableArray<string>),
                 default(ImmutableArray<RefKind>), result.IsDelegateCall, result.Expanded, result.InvokedAsExtensionMethod,
-                argsToParams.ToImmutableAndFree(), result.ResultKind, result.Type);
+                argsToParams.ToImmutableAndFree(), result.ResultKind, result.BinderOpt, result.Type);
         }
 
         private void ReduceQuery(QueryTranslationState state, DiagnosticBag diagnostics)
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundExpression.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundExpression.cs
index f02545f32360b..0101123611edc 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundExpression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundExpression.cs
@@ -424,6 +424,7 @@ internal BoundObjectCreationExpression UpdateArgumentsAndInitializer(
                 argsToParamsOpt: default(ImmutableArray<int>),
                 constantValueOpt: ConstantValueOpt,
                 initializerExpressionOpt: newInitializerExpression,
+                binderOpt: BinderOpt,
                 type: changeTypeOpt ?? Type);
         }
     }
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index e4962d7696bee..b7c5e74d05a2e 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -1201,6 +1201,7 @@
     <Field Name="InvokedAsExtensionMethod" Type="bool"/>
     <Field Name="ArgsToParamsOpt" Type="ImmutableArray&lt;int&gt;" Null="allow"/>
     <Field Name="ResultKind" PropertyOverrides="true" Type="LookupResultKind"/>
+    <Field Name="BinderOpt" Type="Binder" Null="allow"/>
   </Node>
 
   <Node Name="BoundEventAssignmentOperator" Base="BoundExpression">
@@ -1246,6 +1247,7 @@
     <Field Name="ArgsToParamsOpt" Type="ImmutableArray&lt;int&gt;" Null="allow"/>
     <Field Name="ConstantValueOpt" Type="ConstantValue" Null="allow"/>
     <Field Name="InitializerExpressionOpt" Type="BoundExpression" Null="allow"/>
+    <Field Name="BinderOpt" Type="Binder" Null="allow"/>
   </Node>
   
 
@@ -1491,6 +1493,7 @@
     <Field Name="ArgumentRefKindsOpt" Type="ImmutableArray&lt;RefKind&gt;" Null="allow"/>
     <Field Name="Expanded" Type="bool"/>
     <Field Name="ArgsToParamsOpt" Type="ImmutableArray&lt;int&gt;" Null="allow"/>
+    <Field Name="BinderOpt" Type="Binder" Null="allow"/>
   </Node>
 
   <Node Name="BoundDynamicIndexerAccess" Base="BoundExpression">
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundObjectCreationExpression.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundObjectCreationExpression.cs
index 98b6b588d0232..082c447e850f8 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundObjectCreationExpression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundObjectCreationExpression.cs
@@ -7,13 +7,13 @@ namespace Microsoft.CodeAnalysis.CSharp
 {
     internal partial class BoundObjectCreationExpression
     {
-        public BoundObjectCreationExpression(SyntaxNode syntax, MethodSymbol constructor, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, ConstantValue constantValueOpt, BoundExpression initializerExpressionOpt, TypeSymbol type, bool hasErrors = false)
-            : this(syntax, constructor, ImmutableArray<MethodSymbol>.Empty, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, constantValueOpt, initializerExpressionOpt, type, hasErrors)
+        public BoundObjectCreationExpression(SyntaxNode syntax, MethodSymbol constructor, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, ConstantValue constantValueOpt, BoundExpression initializerExpressionOpt, Binder binderOpt, TypeSymbol type, bool hasErrors = false)
+            : this(syntax, constructor, ImmutableArray<MethodSymbol>.Empty, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, constantValueOpt, initializerExpressionOpt, binderOpt, type, hasErrors)
         { }
 
-        public BoundObjectCreationExpression Update(MethodSymbol constructor, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, ConstantValue constantValueOpt, BoundExpression initializerExpressionOpt, TypeSymbol type)
+        public BoundObjectCreationExpression Update(MethodSymbol constructor, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, ConstantValue constantValueOpt, BoundExpression initializerExpressionOpt, Binder binderOpt, TypeSymbol type)
         {
-            return this.Update(constructor, ImmutableArray<MethodSymbol>.Empty, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, constantValueOpt, initializerExpressionOpt, type);
+            return this.Update(constructor, ImmutableArray<MethodSymbol>.Empty, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, constantValueOpt, initializerExpressionOpt, binderOpt, type);
         }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs b/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
index 6f7d940def080..8d3b70508fccc 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
@@ -75,7 +75,8 @@ public static BoundCall ErrorCall(
             bool isDelegateCall,
             bool invokedAsExtensionMethod,
             ImmutableArray<MethodSymbol> originalMethods,
-            LookupResultKind resultKind)
+            LookupResultKind resultKind,
+            Binder binder)
         {
             if (!originalMethods.IsEmpty)
                 resultKind = resultKind.WorseResultKind(LookupResultKind.OverloadResolutionFailure);
@@ -84,14 +85,14 @@ public static BoundCall ErrorCall(
 
             var call = new BoundCall(node, receiverOpt, method, arguments, namedArguments,
                 refKinds, isDelegateCall: isDelegateCall, expanded: false, invokedAsExtensionMethod: invokedAsExtensionMethod, argsToParamsOpt: default(ImmutableArray<int>),
-                resultKind: resultKind, type: method.ReturnType, hasErrors: true);
+                resultKind: resultKind, binderOpt: binder, type: method.ReturnType, hasErrors: true);
             call.OriginalMethodsOpt = originalMethods;
             return call;
         }
 
         public BoundCall Update(BoundExpression receiverOpt, MethodSymbol method, ImmutableArray<BoundExpression> arguments)
         {
-            return this.Update(receiverOpt, method, arguments, ArgumentNamesOpt, ArgumentRefKindsOpt, IsDelegateCall, Expanded, InvokedAsExtensionMethod, ArgsToParamsOpt, ResultKind, Type);
+            return this.Update(receiverOpt, method, arguments, ArgumentNamesOpt, ArgumentRefKindsOpt, IsDelegateCall, Expanded, InvokedAsExtensionMethod, ArgsToParamsOpt, ResultKind, BinderOpt, Type);
         }
 
         public static BoundCall Synthesized(SyntaxNode syntax, BoundExpression receiverOpt, MethodSymbol method)
@@ -122,6 +123,7 @@ public static BoundCall Synthesized(SyntaxNode syntax, BoundExpression receiverO
                     invokedAsExtensionMethod: false,
                     argsToParamsOpt: default(ImmutableArray<int>),
                     resultKind: LookupResultKind.Viable,
+                    binderOpt: null,
                     type: method.ReturnType,
                     hasErrors: method.OriginalDefinition is ErrorMethodSymbol
                 )
@@ -131,12 +133,12 @@ public static BoundCall Synthesized(SyntaxNode syntax, BoundExpression receiverO
 
     internal sealed partial class BoundObjectCreationExpression
     {
-        public BoundObjectCreationExpression(SyntaxNode syntax, MethodSymbol constructor, params BoundExpression[] arguments)
-            : this(syntax, constructor, ImmutableArray.Create<BoundExpression>(arguments), default(ImmutableArray<string>), default(ImmutableArray<RefKind>), false, default(ImmutableArray<int>), null, null, constructor.ContainingType)
+        public BoundObjectCreationExpression(SyntaxNode syntax, MethodSymbol constructor, Binder binderOpt, params BoundExpression[] arguments)
+            : this(syntax, constructor, ImmutableArray.Create<BoundExpression>(arguments), default(ImmutableArray<string>), default(ImmutableArray<RefKind>), false, default(ImmutableArray<int>), null, null, binderOpt, constructor.ContainingType)
         {
         }
-        public BoundObjectCreationExpression(SyntaxNode syntax, MethodSymbol constructor, ImmutableArray<BoundExpression> arguments)
-            : this(syntax, constructor, arguments, default(ImmutableArray<string>), default(ImmutableArray<RefKind>), false, default(ImmutableArray<int>), null, null, constructor.ContainingType)
+        public BoundObjectCreationExpression(SyntaxNode syntax, MethodSymbol constructor, Binder binderOpt, ImmutableArray<BoundExpression> arguments)
+            : this(syntax, constructor, arguments, default(ImmutableArray<string>), default(ImmutableArray<RefKind>), false, default(ImmutableArray<int>), null, null, binderOpt, constructor.ContainingType)
         {
         }
     }
@@ -161,6 +163,7 @@ public static BoundIndexerAccess ErrorAccess(
                 refKinds,
                 expanded: false,
                 argsToParamsOpt: default(ImmutableArray<int>),
+                binderOpt: null,
                 type: indexer.Type,
                 hasErrors: true)
             {
diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index 4e593d5482120..50d8c7093a0e0 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -60,7 +60,7 @@ internal partial class BoundCall : IInvocationExpression
             !this.ReceiverOpt.SuppressVirtualCalls;
 
         ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder
-            => DeriveArguments(this, this.Method, this.Method, this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Method.Parameters, this.Expanded,  this.Syntax, this.InvokedAsExtensionMethod);
+            => DeriveArguments(this, this.BinderOpt, this.Method, this.Method, this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Method.Parameters, this.Expanded,  this.Syntax, this.InvokedAsExtensionMethod);
 
         protected override OperationKind ExpressionKind => OperationKind.InvocationExpression;
 
@@ -77,13 +77,9 @@ public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, T
         private static readonly ConditionalWeakTable<BoundExpression, IEnumerable<IArgument>> s_callToArgumentsMappings 
             = new ConditionalWeakTable<BoundExpression, IEnumerable<IArgument>>();
 
-        // TODO: We need to reuse the logic in `LocalRewriter.MakeArguments` instead of using private implementation. 
-        //       Also. this implementation here was for the (now removed) API `ArgumentsInParameter`, which doesn't fulfill
-        //       the contract of `ArgumentsInEvaluationOrder` plus it doesn't handle various scenarios correctly even for parameter order, 
-        //       e.g. default arguments, erroneous code, etc. 
-        //       https://github.com/dotnet/roslyn/issues/18549
         internal static ImmutableArray<IArgument> DeriveArguments(
             BoundExpression boundNode,
+            Binder binder,
             Symbol methodOrIndexer,
             MethodSymbol optionalParametersMethod,
             ImmutableArray<BoundExpression> boundArguments,
@@ -141,6 +137,7 @@ internal static ImmutableArray<IArgument> DeriveArguments(
                     var parameterSymbolBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameters.Length);
 
                     var derivedArguments = localRewriter.MakeArguments(
+                        binder: binder,
                         syntax: invocationSyntax,
                         arguments: boundArguments,
                         methodOrIndexer: methodOrIndexer,
@@ -276,7 +273,7 @@ internal partial class BoundIndexerAccess : IIndexedPropertyReferenceExpression
         ISymbol IMemberReferenceExpression.Member => this.Indexer;
 
         ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder 
-            => BoundCall.DeriveArguments(this, this.Indexer, this.Indexer.GetOwnOrInheritedGetMethod(),this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Indexer.Parameters, this.Expanded, this.Syntax);
+            => BoundCall.DeriveArguments(this, this.BinderOpt, this.Indexer, this.Indexer.GetOwnOrInheritedGetMethod(),this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Indexer.Parameters, this.Expanded, this.Syntax);
 
         protected override OperationKind ExpressionKind => OperationKind.IndexedPropertyReferenceExpression;
 
@@ -420,7 +417,7 @@ internal partial class BoundObjectCreationExpression : IObjectCreationExpression
         IMethodSymbol IObjectCreationExpression.Constructor => this.Constructor;
 
         ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder 
-            => BoundCall.DeriveArguments(this, this.Constructor, this.Constructor, this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Constructor.Parameters, this.Expanded, this.Syntax);
+            => BoundCall.DeriveArguments(this, this.BinderOpt, this.Constructor, this.Constructor, this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Constructor.Parameters, this.Expanded, this.Syntax);
 
         ImmutableArray<IOperation> IObjectCreationExpression.Initializers => GetChildInitializers(this.InitializerExpressionOpt).As<IOperation>();
 
diff --git a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
index d847d9967a144..84df7969a433a 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
@@ -1141,7 +1141,7 @@ public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpre
             Debug.Assert(node.InitializerExpressionOpt == null);
 
             return node.Update(constructor, rewrittenArguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt,
-                node.Expanded, node.ArgsToParamsOpt, node.ConstantValue, null, node.Type);
+                node.Expanded, node.ArgsToParamsOpt, node.ConstantValue, null, node.BinderOpt, node.Type);
         }
 
         public override BoundNode VisitArrayAccess(BoundArrayAccess node)
@@ -1963,7 +1963,7 @@ public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpre
             ImmutableArray<BoundExpression> arguments = this.VisitList(node.Arguments);
             Debug.Assert(node.InitializerExpressionOpt == null);
             TypeSymbol type = this.VisitType(node.Type);
-            return node.Update(node.Constructor, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.ConstantValueOpt, null, type);
+            return node.Update(node.Constructor, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.ConstantValueOpt, null, node.BinderOpt, type);
         }
 
         public override BoundNode VisitAssignmentOperator(BoundAssignmentOperator node)
diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs b/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs
index 76cefa256a37c..ef370c3b732c8 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs
@@ -47,6 +47,7 @@ internal static ImmutableArray<BoundStatement> ConstructScriptConstructorBody(
                         invokedAsExtensionMethod: false,
                         argsToParamsOpt: ImmutableArray<int>.Empty,
                         resultKind: LookupResultKind.Viable,
+                        binderOpt: null,
                         type: objectType)
                     { WasCompilerGenerated = true })
                 { WasCompilerGenerated = true };
diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
index 5fe5afe4942d1..111acfcf15ff3 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
@@ -1869,6 +1869,7 @@ internal static BoundCall GenerateObjectConstructorInitializer(MethodSymbol cons
                 invokedAsExtensionMethod: false,
                 argsToParamsOpt: ImmutableArray<int>.Empty,
                 resultKind: resultKind,
+                binderOpt: null,
                 type: objectType,
                 hasErrors: hasErrors)
             { WasCompilerGenerated = true };
diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
index b6e0e6fd5f15e..8c22c1a29ae14 100644
--- a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
@@ -4353,7 +4353,7 @@ public BoundPropertyGroup Update(ImmutableArray<PropertySymbol> properties, Boun
 
     internal sealed partial class BoundCall : BoundExpression
     {
-        public BoundCall(SyntaxNode syntax, BoundExpression receiverOpt, MethodSymbol method, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool isDelegateCall, bool expanded, bool invokedAsExtensionMethod, ImmutableArray<int> argsToParamsOpt, LookupResultKind resultKind, TypeSymbol type, bool hasErrors = false)
+        public BoundCall(SyntaxNode syntax, BoundExpression receiverOpt, MethodSymbol method, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool isDelegateCall, bool expanded, bool invokedAsExtensionMethod, ImmutableArray<int> argsToParamsOpt, LookupResultKind resultKind, Binder binderOpt, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.Call, syntax, type, hasErrors || receiverOpt.HasErrors() || arguments.HasErrors())
         {
 
@@ -4371,6 +4371,7 @@ public BoundCall(SyntaxNode syntax, BoundExpression receiverOpt, MethodSymbol me
             this.InvokedAsExtensionMethod = invokedAsExtensionMethod;
             this.ArgsToParamsOpt = argsToParamsOpt;
             this._ResultKind = resultKind;
+            this.BinderOpt = binderOpt;
         }
 
 
@@ -4395,16 +4396,18 @@ public BoundCall(SyntaxNode syntax, BoundExpression receiverOpt, MethodSymbol me
         private readonly LookupResultKind _ResultKind;
         public override LookupResultKind ResultKind { get { return _ResultKind;} }
 
+        public Binder BinderOpt { get; }
+
         public override BoundNode Accept(BoundTreeVisitor visitor)
         {
             return visitor.VisitCall(this);
         }
 
-        public BoundCall Update(BoundExpression receiverOpt, MethodSymbol method, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool isDelegateCall, bool expanded, bool invokedAsExtensionMethod, ImmutableArray<int> argsToParamsOpt, LookupResultKind resultKind, TypeSymbol type)
+        public BoundCall Update(BoundExpression receiverOpt, MethodSymbol method, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool isDelegateCall, bool expanded, bool invokedAsExtensionMethod, ImmutableArray<int> argsToParamsOpt, LookupResultKind resultKind, Binder binderOpt, TypeSymbol type)
         {
-            if (receiverOpt != this.ReceiverOpt || method != this.Method || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || argumentRefKindsOpt != this.ArgumentRefKindsOpt || isDelegateCall != this.IsDelegateCall || expanded != this.Expanded || invokedAsExtensionMethod != this.InvokedAsExtensionMethod || argsToParamsOpt != this.ArgsToParamsOpt || resultKind != this.ResultKind || type != this.Type)
+            if (receiverOpt != this.ReceiverOpt || method != this.Method || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || argumentRefKindsOpt != this.ArgumentRefKindsOpt || isDelegateCall != this.IsDelegateCall || expanded != this.Expanded || invokedAsExtensionMethod != this.InvokedAsExtensionMethod || argsToParamsOpt != this.ArgsToParamsOpt || resultKind != this.ResultKind || binderOpt != this.BinderOpt || type != this.Type)
             {
-                var result = new BoundCall(this.Syntax, receiverOpt, method, arguments, argumentNamesOpt, argumentRefKindsOpt, isDelegateCall, expanded, invokedAsExtensionMethod, argsToParamsOpt, resultKind, type, this.HasErrors);
+                var result = new BoundCall(this.Syntax, receiverOpt, method, arguments, argumentNamesOpt, argumentRefKindsOpt, isDelegateCall, expanded, invokedAsExtensionMethod, argsToParamsOpt, resultKind, binderOpt, type, this.HasErrors);
                 result.WasCompilerGenerated = this.WasCompilerGenerated;
                 return result;
             }
@@ -4505,7 +4508,7 @@ public BoundAttribute Update(MethodSymbol constructor, ImmutableArray<BoundExpre
 
     internal sealed partial class BoundObjectCreationExpression : BoundExpression
     {
-        public BoundObjectCreationExpression(SyntaxNode syntax, MethodSymbol constructor, ImmutableArray<MethodSymbol> constructorsGroup, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, ConstantValue constantValueOpt, BoundExpression initializerExpressionOpt, TypeSymbol type, bool hasErrors = false)
+        public BoundObjectCreationExpression(SyntaxNode syntax, MethodSymbol constructor, ImmutableArray<MethodSymbol> constructorsGroup, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, ConstantValue constantValueOpt, BoundExpression initializerExpressionOpt, Binder binderOpt, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.ObjectCreationExpression, syntax, type, hasErrors || arguments.HasErrors() || initializerExpressionOpt.HasErrors())
         {
 
@@ -4523,6 +4526,7 @@ public BoundObjectCreationExpression(SyntaxNode syntax, MethodSymbol constructor
             this.ArgsToParamsOpt = argsToParamsOpt;
             this.ConstantValueOpt = constantValueOpt;
             this.InitializerExpressionOpt = initializerExpressionOpt;
+            this.BinderOpt = binderOpt;
         }
 
 
@@ -4544,16 +4548,18 @@ public BoundObjectCreationExpression(SyntaxNode syntax, MethodSymbol constructor
 
         public BoundExpression InitializerExpressionOpt { get; }
 
+        public Binder BinderOpt { get; }
+
         public override BoundNode Accept(BoundTreeVisitor visitor)
         {
             return visitor.VisitObjectCreationExpression(this);
         }
 
-        public BoundObjectCreationExpression Update(MethodSymbol constructor, ImmutableArray<MethodSymbol> constructorsGroup, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, ConstantValue constantValueOpt, BoundExpression initializerExpressionOpt, TypeSymbol type)
+        public BoundObjectCreationExpression Update(MethodSymbol constructor, ImmutableArray<MethodSymbol> constructorsGroup, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, ConstantValue constantValueOpt, BoundExpression initializerExpressionOpt, Binder binderOpt, TypeSymbol type)
         {
-            if (constructor != this.Constructor || constructorsGroup != this.ConstructorsGroup || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || argumentRefKindsOpt != this.ArgumentRefKindsOpt || expanded != this.Expanded || argsToParamsOpt != this.ArgsToParamsOpt || constantValueOpt != this.ConstantValueOpt || initializerExpressionOpt != this.InitializerExpressionOpt || type != this.Type)
+            if (constructor != this.Constructor || constructorsGroup != this.ConstructorsGroup || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || argumentRefKindsOpt != this.ArgumentRefKindsOpt || expanded != this.Expanded || argsToParamsOpt != this.ArgsToParamsOpt || constantValueOpt != this.ConstantValueOpt || initializerExpressionOpt != this.InitializerExpressionOpt || binderOpt != this.BinderOpt || type != this.Type)
             {
-                var result = new BoundObjectCreationExpression(this.Syntax, constructor, constructorsGroup, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, constantValueOpt, initializerExpressionOpt, type, this.HasErrors);
+                var result = new BoundObjectCreationExpression(this.Syntax, constructor, constructorsGroup, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, constantValueOpt, initializerExpressionOpt, binderOpt, type, this.HasErrors);
                 result.WasCompilerGenerated = this.WasCompilerGenerated;
                 return result;
             }
@@ -5418,7 +5424,7 @@ public BoundEventAccess Update(BoundExpression receiverOpt, EventSymbol eventSym
 
     internal sealed partial class BoundIndexerAccess : BoundExpression
     {
-        public BoundIndexerAccess(SyntaxNode syntax, BoundExpression receiverOpt, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, TypeSymbol type, bool hasErrors = false)
+        public BoundIndexerAccess(SyntaxNode syntax, BoundExpression receiverOpt, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, Binder binderOpt, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.IndexerAccess, syntax, type, hasErrors || receiverOpt.HasErrors() || arguments.HasErrors())
         {
 
@@ -5433,6 +5439,7 @@ public BoundIndexerAccess(SyntaxNode syntax, BoundExpression receiverOpt, Proper
             this.ArgumentRefKindsOpt = argumentRefKindsOpt;
             this.Expanded = expanded;
             this.ArgsToParamsOpt = argsToParamsOpt;
+            this.BinderOpt = binderOpt;
         }
 
 
@@ -5450,16 +5457,18 @@ public BoundIndexerAccess(SyntaxNode syntax, BoundExpression receiverOpt, Proper
 
         public ImmutableArray<int> ArgsToParamsOpt { get; }
 
+        public Binder BinderOpt { get; }
+
         public override BoundNode Accept(BoundTreeVisitor visitor)
         {
             return visitor.VisitIndexerAccess(this);
         }
 
-        public BoundIndexerAccess Update(BoundExpression receiverOpt, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, TypeSymbol type)
+        public BoundIndexerAccess Update(BoundExpression receiverOpt, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, Binder binderOpt, TypeSymbol type)
         {
-            if (receiverOpt != this.ReceiverOpt || indexer != this.Indexer || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || argumentRefKindsOpt != this.ArgumentRefKindsOpt || expanded != this.Expanded || argsToParamsOpt != this.ArgsToParamsOpt || type != this.Type)
+            if (receiverOpt != this.ReceiverOpt || indexer != this.Indexer || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || argumentRefKindsOpt != this.ArgumentRefKindsOpt || expanded != this.Expanded || argsToParamsOpt != this.ArgsToParamsOpt || binderOpt != this.BinderOpt || type != this.Type)
             {
-                var result = new BoundIndexerAccess(this.Syntax, receiverOpt, indexer, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, type, this.HasErrors);
+                var result = new BoundIndexerAccess(this.Syntax, receiverOpt, indexer, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, binderOpt, type, this.HasErrors);
                 result.WasCompilerGenerated = this.WasCompilerGenerated;
                 return result;
             }
@@ -8964,7 +8973,7 @@ public override BoundNode VisitCall(BoundCall node)
             BoundExpression receiverOpt = (BoundExpression)this.Visit(node.ReceiverOpt);
             ImmutableArray<BoundExpression> arguments = (ImmutableArray<BoundExpression>)this.VisitList(node.Arguments);
             TypeSymbol type = this.VisitType(node.Type);
-            return node.Update(receiverOpt, node.Method, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.IsDelegateCall, node.Expanded, node.InvokedAsExtensionMethod, node.ArgsToParamsOpt, node.ResultKind, type);
+            return node.Update(receiverOpt, node.Method, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.IsDelegateCall, node.Expanded, node.InvokedAsExtensionMethod, node.ArgsToParamsOpt, node.ResultKind, node.BinderOpt, type);
         }
         public override BoundNode VisitEventAssignmentOperator(BoundEventAssignmentOperator node)
         {
@@ -8985,7 +8994,7 @@ public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpre
             ImmutableArray<BoundExpression> arguments = (ImmutableArray<BoundExpression>)this.VisitList(node.Arguments);
             BoundExpression initializerExpressionOpt = (BoundExpression)this.Visit(node.InitializerExpressionOpt);
             TypeSymbol type = this.VisitType(node.Type);
-            return node.Update(node.Constructor, node.ConstructorsGroup, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.ConstantValueOpt, initializerExpressionOpt, type);
+            return node.Update(node.Constructor, node.ConstructorsGroup, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.ConstantValueOpt, initializerExpressionOpt, node.BinderOpt, type);
         }
         public override BoundNode VisitTupleLiteral(BoundTupleLiteral node)
         {
@@ -9124,7 +9133,7 @@ public override BoundNode VisitIndexerAccess(BoundIndexerAccess node)
             BoundExpression receiverOpt = (BoundExpression)this.Visit(node.ReceiverOpt);
             ImmutableArray<BoundExpression> arguments = (ImmutableArray<BoundExpression>)this.VisitList(node.Arguments);
             TypeSymbol type = this.VisitType(node.Type);
-            return node.Update(receiverOpt, node.Indexer, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, type);
+            return node.Update(receiverOpt, node.Indexer, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.BinderOpt, type);
         }
         public override BoundNode VisitDynamicIndexerAccess(BoundDynamicIndexerAccess node)
         {
@@ -10313,6 +10322,7 @@ public override TreeDumperNode VisitCall(BoundCall node, object arg)
                 new TreeDumperNode("invokedAsExtensionMethod", node.InvokedAsExtensionMethod, null),
                 new TreeDumperNode("argsToParamsOpt", node.ArgsToParamsOpt, null),
                 new TreeDumperNode("resultKind", node.ResultKind, null),
+                new TreeDumperNode("binderOpt", node.BinderOpt, null),
                 new TreeDumperNode("type", node.Type, null)
             }
             );
@@ -10356,6 +10366,7 @@ public override TreeDumperNode VisitObjectCreationExpression(BoundObjectCreation
                 new TreeDumperNode("argsToParamsOpt", node.ArgsToParamsOpt, null),
                 new TreeDumperNode("constantValueOpt", node.ConstantValueOpt, null),
                 new TreeDumperNode("initializerExpressionOpt", null, new TreeDumperNode[] { Visit(node.InitializerExpressionOpt, null) }),
+                new TreeDumperNode("binderOpt", node.BinderOpt, null),
                 new TreeDumperNode("type", node.Type, null)
             }
             );
@@ -10602,6 +10613,7 @@ public override TreeDumperNode VisitIndexerAccess(BoundIndexerAccess node, objec
                 new TreeDumperNode("argumentRefKindsOpt", node.ArgumentRefKindsOpt, null),
                 new TreeDumperNode("expanded", node.Expanded, null),
                 new TreeDumperNode("argsToParamsOpt", node.ArgsToParamsOpt, null),
+                new TreeDumperNode("binderOpt", node.BinderOpt, null),
                 new TreeDumperNode("type", node.Type, null)
             }
             );
diff --git a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AwaitExpressionSpiller.cs b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AwaitExpressionSpiller.cs
index 5b9c0b56eafd2..dc56bc050b763 100644
--- a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AwaitExpressionSpiller.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AwaitExpressionSpiller.cs
@@ -1041,7 +1041,7 @@ public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpre
             Debug.Assert(node.InitializerExpressionOpt == null);
             BoundSpillSequenceBuilder builder = null;
             var arguments = this.VisitExpressionList(ref builder, node.Arguments, node.ArgumentRefKindsOpt);
-            return UpdateExpression(builder, node.Update(node.Constructor, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.ConstantValueOpt, node.InitializerExpressionOpt, node.Type));
+            return UpdateExpression(builder, node.Update(node.Constructor, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.ConstantValueOpt, node.InitializerExpressionOpt, node.BinderOpt, node.Type));
         }
 
         public override BoundNode VisitPointerElementAccess(BoundPointerElementAccess node)
diff --git a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
index 9830f0705377c..527a609676837 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
@@ -892,6 +892,7 @@ public override BoundNode VisitCall(BoundCall node)
                     node.InvokedAsExtensionMethod,
                     node.ArgsToParamsOpt,
                     node.ResultKind,
+                    node.BinderOpt,
                     this.VisitType(node.Type));
 
                 return PartiallyLowerLocalFunctionReference(withArguments);
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_AnonymousObjectCreation.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_AnonymousObjectCreation.cs
index 03c4f0f2cb53b..58039e05a3874 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_AnonymousObjectCreation.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_AnonymousObjectCreation.cs
@@ -25,6 +25,7 @@ public override BoundNode VisitAnonymousObjectCreationExpression(BoundAnonymousO
                 argsToParamsOpt: default(ImmutableArray<int>),
                 constantValueOpt: null,
                 initializerExpressionOpt: null,
+                binderOpt: null,
                 type: node.Type);
         }
     }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs
index 79f3e1e825424..28487f45acd43 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs
@@ -1195,6 +1195,7 @@ private BoundExpression MakeLiftedBinaryOperatorConsequence(
             return new BoundObjectCreationExpression(
                 syntax,
                 UnsafeGetNullableMethod(syntax, type, SpecialMember.System_Nullable_T__ctor),
+                null, 
                 unliftedOp);
         }
 
@@ -1484,6 +1485,7 @@ private BoundExpression MakeNewNullableBoolean(SyntaxNode syntax, bool? value)
             return new BoundObjectCreationExpression(
                 syntax,
                 UnsafeGetNullableMethod(syntax, nullableBoolType, SpecialMember.System_Nullable_T__ctor),
+                null,
                 MakeBooleanConstant(syntax, value.GetValueOrDefault()));
         }
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index a4421551f0b38..83a99365ee6bb 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -224,6 +224,7 @@ private BoundExpression MakeCall(
                     invokedAsExtensionMethod: invokedAsExtensionMethod,
                     argsToParamsOpt: default(ImmutableArray<int>),
                     resultKind: resultKind,
+                    binderOpt: null,
                     type: type);
             }
             else
@@ -239,6 +240,7 @@ private BoundExpression MakeCall(
                     node.InvokedAsExtensionMethod,
                     default(ImmutableArray<int>),
                     node.ResultKind,
+                    node.BinderOpt,
                     node.Type);
             }
 
@@ -491,6 +493,7 @@ internal ImmutableArray<BoundExpression> MakeArguments(
         }
 
         internal ImmutableArray<BoundExpression> MakeArguments(
+            Binder binder,
             SyntaxNode syntax,
             ImmutableArray<BoundExpression> arguments,
             Symbol methodOrIndexer,
@@ -825,6 +828,7 @@ private BoundExpression CreateParamArrayArgument(SyntaxNode syntax, Symbol metho
                             invokedAsExtensionMethod: false,
                             argsToParamsOpt: default(ImmutableArray<int>),
                             resultKind: LookupResultKind.Viable,
+                            binderOpt: null,
                             type: arrayEmpty.ReturnType);
                     }
                 }
@@ -1104,6 +1108,7 @@ private BoundExpression GetDefaultParameterValue(SyntaxNode syntax, ParameterSym
                         defaultValue = new BoundObjectCreationExpression(
                             syntax,
                             UnsafeGetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
+                            null,
                             defaultValue);
                     }
                     else
@@ -1233,6 +1238,7 @@ private BoundExpression GetDefaultParameterValue(SyntaxNode syntax, ParameterSym
                     defaultValue = new BoundObjectCreationExpression(
                         syntax,
                         UnsafeGetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
+                        null,
                         defaultValue);
 
                 }
@@ -1286,14 +1292,14 @@ private BoundExpression GetDefaultParameterSpecial(SyntaxNode syntax, ParameterS
                 // new UnknownWrapper(default(object))
                 var methodSymbol = (MethodSymbol)_compilation.GetWellKnownTypeMember(WellKnownMember.System_Runtime_InteropServices_UnknownWrapper__ctor);
                 var argument = new BoundDefaultExpression(syntax, parameter.Type);
-                defaultValue = new BoundObjectCreationExpression(syntax, methodSymbol, argument);
+                defaultValue = new BoundObjectCreationExpression(syntax, methodSymbol, null, argument);
             }
             else if (parameter.IsIDispatchConstant)
             {
                 // new DispatchWrapper(default(object))
                 var methodSymbol = (MethodSymbol)_compilation.GetWellKnownTypeMember(WellKnownMember.System_Runtime_InteropServices_DispatchWrapper__ctor);
                 var argument = new BoundDefaultExpression(syntax, parameter.Type);
-                defaultValue = new BoundObjectCreationExpression(syntax, methodSymbol, argument);
+                defaultValue = new BoundObjectCreationExpression(syntax, methodSymbol, null, argument);
             }
             else
             {
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs
index 1e8f69755e997..891b2dc430380 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs
@@ -328,6 +328,7 @@ private BoundIndexerAccess TransformIndexerAccess(BoundIndexerAccess indexerAcce
                 argumentRefKinds,
                 false,
                 default(ImmutableArray<int>),
+                null,
                 indexerAccess.Type);
         }
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
index 3ff46b9d2e426..966bbf45537d6 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
@@ -745,7 +745,7 @@ private BoundExpression RewriteNullableConversion(
 
                 BoundExpression rewrittenConversion = MakeConversionNode(syntax, rewrittenOperand, conversion.UnderlyingConversions[0], rewrittenType.GetNullableUnderlyingType(), @checked);
                 MethodSymbol ctor = UnsafeGetNullableMethod(syntax, rewrittenType, SpecialMember.System_Nullable_T__ctor);
-                return new BoundObjectCreationExpression(syntax, ctor, rewrittenConversion);
+                return new BoundObjectCreationExpression(syntax, ctor, null, rewrittenConversion);
             }
             else
             {
@@ -851,6 +851,7 @@ private BoundExpression RewriteFullyLiftedBuiltInConversion(
             BoundExpression consequence = new BoundObjectCreationExpression(
                 syntax,
                 UnsafeGetNullableMethod(syntax, type, SpecialMember.System_Nullable_T__ctor),
+                null,
                 MakeConversionNode(
                     syntax,
                     BoundCall.Synthesized(syntax, boundTemp, getValueOrDefault),
@@ -926,6 +927,7 @@ private BoundExpression OptimizeLiftedBuiltInConversion(
                 return new BoundObjectCreationExpression(
                     syntax,
                     UnsafeGetNullableMethod(syntax, type, SpecialMember.System_Nullable_T__ctor),
+                    null,
                     MakeConversionNode(
                         syntax,
                         nonNullValue,
@@ -1031,7 +1033,7 @@ private BoundExpression MakeLiftedUserDefinedConversionConsequence(BoundCall cal
             {
                 Debug.Assert(resultType.IsNullableType() && resultType.GetNullableUnderlyingType() == call.Method.ReturnType);
                 MethodSymbol ctor = UnsafeGetNullableMethod(call.Syntax, resultType, SpecialMember.System_Nullable_T__ctor);
-                return new BoundObjectCreationExpression(call.Syntax, ctor, call);
+                return new BoundObjectCreationExpression(call.Syntax, ctor, null, call);
             }
 
             return call;
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_IndexerAccess.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_IndexerAccess.cs
index d2ae090a187da..628a768ab72b9 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_IndexerAccess.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_IndexerAccess.cs
@@ -105,8 +105,8 @@ private BoundExpression MakeIndexerAccess(
                 // This node will be rewritten with MakePropertyAssignment when rewriting the enclosing BoundAssignmentOperator.
 
                 return oldNodeOpt != null ?
-                    oldNodeOpt.Update(rewrittenReceiver, indexer, rewrittenArguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, type) :
-                    new BoundIndexerAccess(syntax, rewrittenReceiver, indexer, rewrittenArguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, type);
+                    oldNodeOpt.Update(rewrittenReceiver, indexer, rewrittenArguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, null, type) :
+                    new BoundIndexerAccess(syntax, rewrittenReceiver, indexer, rewrittenArguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, null, type);
             }
             else
             {
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs
index 264d08a50d1e9..d8ba8ef9e36a3 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs
@@ -135,7 +135,7 @@ private BoundExpression MakeDecimalLiteral(SyntaxNode syntax, ConstantValue cons
             return new BoundObjectCreationExpression(
                 syntax, ctor, arguments.ToImmutableAndFree(),
                 default(ImmutableArray<string>), default(ImmutableArray<RefKind>), false, default(ImmutableArray<int>),
-                constantValue, null, ctor.ContainingType);
+                constantValue, null, null, ctor.ContainingType);
         }
 
         private BoundExpression MakeDateTimeLiteral(SyntaxNode syntax, ConstantValue constantValue)
@@ -154,7 +154,7 @@ private BoundExpression MakeDateTimeLiteral(SyntaxNode syntax, ConstantValue con
             return new BoundObjectCreationExpression(
                 syntax, ctor, arguments.ToImmutableAndFree(),
                 default(ImmutableArray<string>), default(ImmutableArray<RefKind>), false, default(ImmutableArray<int>),
-                ConstantValue.NotAvailable, null, ctor.ContainingType);
+                ConstantValue.NotAvailable, null, null, ctor.ContainingType);
         }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
index a0bb56b340dde..38b8b5d4c20f3 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
@@ -203,6 +203,7 @@ private BoundExpression MakeNewT(SyntaxNode syntax, TypeParameterSymbol typePara
                 invokedAsExtensionMethod: false,
                 argsToParamsOpt: default(ImmutableArray<int>),
                 resultKind: LookupResultKind.Viable,
+                binderOpt: null,
                 type: typeParameter);
 
             return createInstanceCall;
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TupleCreationExpression.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TupleCreationExpression.cs
index ad637c2120f2b..8dbab708121b9 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TupleCreationExpression.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TupleCreationExpression.cs
@@ -60,7 +60,7 @@ private BoundExpression MakeTupleCreationExpression(SyntaxNode syntax, NamedType
                 }
 
                 MethodSymbol smallestConstructor = smallestCtor.AsMember(smallestType);
-                BoundObjectCreationExpression currentCreation = new BoundObjectCreationExpression(syntax, smallestConstructor, smallestCtorArguments);
+                BoundObjectCreationExpression currentCreation = new BoundObjectCreationExpression(syntax, smallestConstructor, null, smallestCtorArguments);
 
                 if (underlyingTupleTypeChain.Count > 0)
                 {
@@ -83,7 +83,7 @@ private BoundExpression MakeTupleCreationExpression(SyntaxNode syntax, NamedType
                                                                                       .Add(currentCreation);
 
                         MethodSymbol constructor = tuple8Ctor.AsMember(underlyingTupleTypeChain.Pop());
-                        currentCreation = new BoundObjectCreationExpression(syntax, constructor, ctorArguments);
+                        currentCreation = new BoundObjectCreationExpression(syntax, constructor, null, ctorArguments);
                     }
                     while (underlyingTupleTypeChain.Count > 0);
                 }
@@ -96,7 +96,8 @@ private BoundExpression MakeTupleCreationExpression(SyntaxNode syntax, NamedType
                     currentCreation.Expanded, 
                     currentCreation.ArgsToParamsOpt, 
                     currentCreation.ConstantValue, 
-                    currentCreation.InitializerExpressionOpt, 
+                    currentCreation.InitializerExpressionOpt,
+                    currentCreation.BinderOpt,
                     type);
 
                 return currentCreation;
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_UnaryOperator.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_UnaryOperator.cs
index b3c64901f9383..6d19d2eb3b737 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_UnaryOperator.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_UnaryOperator.cs
@@ -348,6 +348,7 @@ private BoundExpression GetLiftedUnaryOperatorConsequence(UnaryOperatorKind kind
             BoundExpression consequence = new BoundObjectCreationExpression(
                     syntax,
                     ctor,
+                    null,
                     unliftedOp);
             return consequence;
         }
@@ -633,7 +634,7 @@ private BoundExpression MakeUserDefinedIncrementOperator(BoundIncrementOperator
             BoundExpression userDefinedCall = BoundCall.Synthesized(syntax, null, node.MethodOpt, call_GetValueOrDefault);
 
             // new S?(op_Increment(temp.GetValueOrDefault()))
-            BoundExpression consequence = new BoundObjectCreationExpression(syntax, ctor, userDefinedCall);
+            BoundExpression consequence = new BoundObjectCreationExpression(syntax, ctor, null, userDefinedCall);
 
             // default(S?)
             BoundExpression alternative = new BoundDefaultExpression(syntax, null, type);
@@ -700,7 +701,7 @@ private BoundExpression MakeBuiltInIncrementOperator(BoundIncrementOperator node
             {
                 binaryOperandType = _compilation.GetSpecialType(SpecialType.System_Nullable_T).Construct(binaryOperandType);
                 MethodSymbol ctor = UnsafeGetNullableMethod(node.Syntax, binaryOperandType, SpecialMember.System_Nullable_T__ctor);
-                boundOne = new BoundObjectCreationExpression(node.Syntax, ctor, boundOne);
+                boundOne = new BoundObjectCreationExpression(node.Syntax, ctor, null, boundOne);
             }
 
             // Now we construct the other operand to the binary addition. We start with just plain "x".
@@ -800,7 +801,7 @@ private BoundExpression MakeLiftedDecimalIncDecOperator(SyntaxNode syntax, Binar
             // op_Inc(x.GetValueOrDefault())
             BoundExpression methodCall = BoundCall.Synthesized(syntax, null, method, getValueCall);
             // new decimal?(op_Inc(x.GetValueOrDefault()))
-            BoundExpression consequence = new BoundObjectCreationExpression(syntax, ctor, methodCall);
+            BoundExpression consequence = new BoundObjectCreationExpression(syntax, ctor, null, methodCall);
             // default(decimal?)
             BoundExpression alternative = new BoundDefaultExpression(syntax, null, operand.Type);
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
index 4b8e2d4becf59..4005e66d8c8fb 100644
--- a/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
@@ -255,6 +255,7 @@ public override BoundNode VisitCall(BoundCall node)
                 node.InvokedAsExtensionMethod,
                 node.ArgsToParamsOpt,
                 node.ResultKind,
+                node.BinderOpt,
                 rewrittenType);
         }
 
@@ -471,6 +472,7 @@ public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpre
                     rewritten.ArgsToParamsOpt,
                     rewritten.ConstantValueOpt,
                     rewritten.InitializerExpressionOpt,
+                    rewritten.BinderOpt,
                     rewritten.Type);
             }
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
index 26accb2f4553a..e0e09cccab16d 100644
--- a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
@@ -576,7 +576,7 @@ public BoundObjectCreationExpression New(NamedTypeSymbol type, params BoundExpre
         public BoundObjectCreationExpression New(MethodSymbol ctor, params BoundExpression[] args)
         {
             // TODO: add diagnostics for when things fall apart
-            return new BoundObjectCreationExpression(Syntax, ctor, args) { WasCompilerGenerated = true };
+            return new BoundObjectCreationExpression(Syntax, ctor, null, args) { WasCompilerGenerated = true };
         }
 
         public BoundExpression InstanceCall(BoundExpression receiver, string name, BoundExpression arg)
@@ -643,7 +643,7 @@ public BoundCall Call(BoundExpression receiver, MethodSymbol method, ImmutableAr
             return new BoundCall(
                 Syntax, receiver, method, args,
                 ImmutableArray<String>.Empty, ImmutableArray<RefKind>.Empty, false, false, false,
-                default(ImmutableArray<int>), LookupResultKind.Viable, method.ReturnType,
+                default(ImmutableArray<int>), LookupResultKind.Viable, null, method.ReturnType,
                 hasErrors:method.OriginalDefinition is ErrorMethodSymbol)
             { WasCompilerGenerated = true };
         }
@@ -654,7 +654,7 @@ public BoundCall Call(BoundExpression receiver, MethodSymbol method, ImmutableAr
             return new BoundCall(
                 Syntax, receiver, method, args,
                 ImmutableArray<String>.Empty, refKinds, false, false, false,
-                ImmutableArray<int>.Empty, LookupResultKind.Viable, method.ReturnType)
+                ImmutableArray<int>.Empty, LookupResultKind.Viable, null, method.ReturnType)
             { WasCompilerGenerated = true };
         }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
index 7dff9eb3426f5..89aa17d7a95a2 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
@@ -319,6 +319,7 @@ private static BoundCall CreateParameterlessCall(CSharpSyntaxNode syntax, BoundE
                 invokedAsExtensionMethod: false,
                 argsToParamsOpt: default(ImmutableArray<int>),
                 resultKind: LookupResultKind.Viable,
+                binderOpt: null,
                 type: method.ReturnType)
             { WasCompilerGenerated = true };
         }
@@ -482,7 +483,8 @@ internal override BoundBlock CreateBody()
                                 scriptLocal,
                                 new BoundObjectCreationExpression(
                                     syntax,
-                                    ctor)
+                                    ctor,
+                                    null)
                                 { WasCompilerGenerated = true },
                                 _containingType)
                             { WasCompilerGenerated = true })
@@ -576,6 +578,7 @@ internal override BoundBlock CreateBody()
                             default(ImmutableArray<int>),
                             null,
                             null,
+                            null,
                             _containingType)
                         { WasCompilerGenerated = true },
                         _containingType)

From c6816538652fce58be04038485d0a6049a31dfd4 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Sat, 6 May 2017 15:45:23 -0700
Subject: [PATCH 163/284] Refactor LocalRewriter to remove IOperation's
 dependency on instance methods

---
 .../CSharp/Portable/BoundTree/Expression.cs   |  19 +-
 .../Lowering/LocalRewriter/LocalRewriter.cs   |  27 +-
 .../LocalRewriter_BinaryOperator.cs           |   7 +-
 .../LocalRewriter/LocalRewriter_Call.cs       | 246 ++++++++++--------
 .../LocalRewriter/LocalRewriter_Conversion.cs |  54 +++-
 .../LocalRewriter/LocalRewriter_Literal.cs    |  57 ++--
 .../Lowering/SyntheticBoundNodeFactory.cs     |  29 ++-
 .../IOperation/IOperationTests_IArgument.cs   |  79 +++++-
 .../IOperationTests_IIfStatement.cs           |   2 +-
 9 files changed, 335 insertions(+), 185 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index 50d8c7093a0e0..c631755d66d1f 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -116,27 +116,12 @@ internal static ImmutableArray<IArgument> DeriveArguments(
                         }
 
                         return argumentsWithErrors.ToImmutableAndFree();
-                    }
-
-                    var diagnosticBag = new DiagnosticBag();
-                    var factory = new SyntheticBoundNodeFactory(invocationSyntax, diagnosticBag);
-                    var localRewriter = new LocalRewriter(
-                                            compilation: null,
-                                            containingMethod: null,
-                                            containingMethodOrdinal: 0,
-                                            rootStatement: null,
-                                            containingType: null,
-                                            factory: factory,
-                                            previousSubmissionFields: null,
-                                            allowOmissionOfConditionalCalls: false,
-                                            diagnostics: diagnosticBag,
-                                            instrumenter: null,
-                                            inOperationContext: true);
+                    } 
 
                     var argumentKindBuilder = ArrayBuilder<ArgumentKind>.GetInstance(parameters.Length);
                     var parameterSymbolBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameters.Length);
 
-                    var derivedArguments = localRewriter.MakeArguments(
+                    var derivedArguments = LocalRewriter.MakeArgumentsInEvaluationOrder(
                         binder: binder,
                         syntax: invocationSyntax,
                         arguments: boundArguments,
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
index e87158d798d08..38f2704bf686f 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
@@ -29,8 +29,6 @@ internal sealed partial class LocalRewriter : BoundTreeRewriterWithStackGuard
         private readonly Instrumenter _instrumenter;
         private readonly BoundStatement _rootStatement;
 
-        private bool _inOperationContext;
-
         private Dictionary<BoundValuePlaceholderBase, BoundExpression> _placeholderReplacementMapDoNotUseDirectly;
 
         internal LocalRewriter(
@@ -43,8 +41,7 @@ internal LocalRewriter(
             SynthesizedSubmissionFields previousSubmissionFields,
             bool allowOmissionOfConditionalCalls,
             DiagnosticBag diagnostics,
-            Instrumenter instrumenter,
-            bool inOperationContext = false)
+            Instrumenter instrumenter)
         {
             _compilation = compilation;
             _factory = factory;
@@ -55,11 +52,9 @@ internal LocalRewriter(
             _allowOmissionOfConditionalCalls = allowOmissionOfConditionalCalls;
             _diagnostics = diagnostics;
 
-            Debug.Assert(instrumenter != null || inOperationContext);
+            Debug.Assert(instrumenter != null);
             _instrumenter = instrumenter;
             _rootStatement = rootStatement;
-
-            _inOperationContext = inOperationContext;
         }
 
         /// <summary>
@@ -323,9 +318,14 @@ private bool TryGetWellKnownTypeMember<TSymbol>(SyntaxNode syntax, WellKnownMemb
         /// If used, a unit-test with a missing member is absolutely a must have.
         /// </summary>
         private MethodSymbol UnsafeGetSpecialTypeMethod(SyntaxNode syntax, SpecialMember specialMember)
+        {
+            return UnsafeGetSpecialTypeMethod(syntax, specialMember, _compilation, _diagnostics);
+        }
+
+        private static MethodSymbol UnsafeGetSpecialTypeMethod(SyntaxNode syntax, SpecialMember specialMember, CSharpCompilation compilation, DiagnosticBag diagnostics)
         {
             MethodSymbol method;
-            if (TryGetSpecialTypeMethod(syntax, specialMember, out method))
+            if (TryGetSpecialTypeMethod(syntax, specialMember, compilation, diagnostics, out method))
             {
                 return method;
             }
@@ -333,15 +333,20 @@ private MethodSymbol UnsafeGetSpecialTypeMethod(SyntaxNode syntax, SpecialMember
             {
                 MemberDescriptor descriptor = SpecialMembers.GetDescriptor(specialMember);
                 SpecialType type = (SpecialType)descriptor.DeclaringTypeId;
-                TypeSymbol container = _compilation.Assembly.GetSpecialType(type);
-                TypeSymbol returnType = new ExtendedErrorTypeSymbol(compilation: _compilation, name: descriptor.Name, errorInfo: null, arity: descriptor.Arity);
+                TypeSymbol container = compilation.Assembly.GetSpecialType(type);
+                TypeSymbol returnType = new ExtendedErrorTypeSymbol(compilation: compilation, name: descriptor.Name, errorInfo: null, arity: descriptor.Arity);
                 return new ErrorMethodSymbol(container, returnType, "Missing");
             }
         }
 
         private bool TryGetSpecialTypeMethod(SyntaxNode syntax, SpecialMember specialMember, out MethodSymbol method)
         {
-            return Binder.TryGetSpecialTypeMember(_compilation, specialMember, syntax, _diagnostics, out method);
+            return TryGetSpecialTypeMethod(syntax, specialMember, _compilation, _diagnostics, out method);
+        }
+
+        private static bool TryGetSpecialTypeMethod(SyntaxNode syntax, SpecialMember specialMember, CSharpCompilation compilation, DiagnosticBag diagnostics, out MethodSymbol method)
+        {
+            return Binder.TryGetSpecialTypeMember(compilation, specialMember, syntax, diagnostics, out method);
         }
 
         public override BoundNode VisitTypeOfOperator(BoundTypeOfOperator node)
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs
index 28487f45acd43..f6f40b7dc7a64 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs
@@ -1721,10 +1721,15 @@ private BoundExpression LowerLiftedBooleanOperator(
         /// If used, a unit-test with a missing member is absolutely a must have.
         /// </summary>
         private MethodSymbol UnsafeGetNullableMethod(SyntaxNode syntax, TypeSymbol nullableType, SpecialMember member)
+        {
+            return UnsafeGetNullableMethod(syntax, nullableType, member, _compilation, _diagnostics);
+        }
+
+        private static MethodSymbol UnsafeGetNullableMethod(SyntaxNode syntax, TypeSymbol nullableType, SpecialMember member, CSharpCompilation compilation, DiagnosticBag diagnostics)
         {
             var nullableType2 = nullableType as NamedTypeSymbol;
             Debug.Assert((object)nullableType2 != null);
-            return UnsafeGetSpecialTypeMethod(syntax, member).AsMember(nullableType2);
+            return UnsafeGetSpecialTypeMethod(syntax, member, compilation, diagnostics).AsMember(nullableType2);
         }
 
         private bool TryGetNullableMethod(SyntaxNode syntax, TypeSymbol nullableType, SpecialMember member, out MethodSymbol result)
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index 83a99365ee6bb..8a5f7472a5010 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -373,8 +373,6 @@ internal ImmutableArray<BoundExpression> MakeArguments(
             bool invokedAsExtensionMethod = false,
             ThreeState enableCallerInfo = ThreeState.Unknown)
         {
-            Debug.Assert(!_inOperationContext);
-
             // Either the methodOrIndexer is a property, in which case the method used
             // for optional parameters is an accessor of that property (or an overridden
             // property), or the methodOrIndexer is used for optional parameters directly.
@@ -390,7 +388,7 @@ internal ImmutableArray<BoundExpression> MakeArguments(
             //
             // If none of those are the case then we can just take an early out.
 
-            if (TryReturnEarly(ref rewrittenArguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, out var isComReceiver, out var temporariesBuilder))
+            if (TryReturnEarly(ref rewrittenArguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, _factory, out var isComReceiver, out var temporariesBuilder))
             {
                 temps = temporariesBuilder?.ToImmutableAndFree() ?? default(ImmutableArray<LocalSymbol>);
                 return rewrittenArguments;
@@ -492,7 +490,7 @@ internal ImmutableArray<BoundExpression> MakeArguments(
             return actualArguments.AsImmutableOrNull();
         }
 
-        internal ImmutableArray<BoundExpression> MakeArguments(
+        internal static ImmutableArray<BoundExpression> MakeArgumentsInEvaluationOrder(
             Binder binder,
             SyntaxNode syntax,
             ImmutableArray<BoundExpression> arguments,
@@ -505,7 +503,7 @@ internal ImmutableArray<BoundExpression> MakeArguments(
             /* out */ ArrayBuilder<ParameterSymbol> parameterSymbolBuilder,
             ThreeState enableCallerInfo = ThreeState.Unknown)
         {
-            Debug.Assert(_inOperationContext && argumentKindBuilder.IsEmpty() && parameterSymbolBuilder.IsEmpty());
+            Debug.Assert(binder != null && argumentKindBuilder.IsEmpty() && parameterSymbolBuilder.IsEmpty());
 
             // Either the methodOrIndexer is a property, in which case the method used
             // for optional parameters is an accessor of that property (or an overridden
@@ -524,7 +522,7 @@ internal ImmutableArray<BoundExpression> MakeArguments(
 
             ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters();
 
-            if (TryReturnEarly(ref arguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, out var isComReceiver, out var temporariesBuilder))
+            if (TryReturnEarly(ref arguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, null, out var isComReceiver, out var temporariesBuilder))
             {
                 // In this case, the invocation is not in expanded form and there's no named argument provided.
                 // So we just return list of arguments as is.
@@ -541,20 +539,21 @@ internal ImmutableArray<BoundExpression> MakeArguments(
             ArrayBuilder<BoundExpression> argumentsBuilder = ArrayBuilder<BoundExpression>.GetInstance(parameters.Length);
             ArrayBuilder<ParameterSymbol> missingParametersBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameters.Length);
 
-            BuildArgumentsInEvaluationOrder(syntax, methodOrIndexer, expanded, argsToParamsOpt, arguments, argumentsBuilder, argumentKindBuilder, parameterSymbolBuilder, missingParametersBuilder);
+            BuildExplicitArgumentsInEvaluationOrder(syntax, methodOrIndexer, expanded, argsToParamsOpt, arguments, binder.Compilation, argumentsBuilder, argumentKindBuilder, parameterSymbolBuilder, missingParametersBuilder);
 
-            AppendMissingOptionalArguments(syntax, missingParametersBuilder.ToImmutableAndFree(), argumentsBuilder, argumentKindBuilder, parameterSymbolBuilder);
+            AppendMissingOptionalArguments(syntax, missingParametersBuilder.ToImmutableAndFree(), binder, argumentsBuilder, argumentKindBuilder, parameterSymbolBuilder);
 
             return argumentsBuilder.ToImmutableAndFree();
         }
 
-        // temporariesBuilder will be null when _inOperationContext is true.
-        private bool TryReturnEarly(
+        // temporariesBuilder will be null when factory is null.
+        private static bool TryReturnEarly(
             ref ImmutableArray<BoundExpression> rewrittenArguments,
             Symbol methodOrIndexer,
             bool expanded,
             ImmutableArray<int> argsToParamsOpt,
             bool invokedAsExtensionMethod,
+            SyntheticBoundNodeFactory factory,
             out bool isComReceiver,
             out ArrayBuilder<LocalSymbol> temporariesBuilder)
         {
@@ -580,10 +579,10 @@ private bool TryReturnEarly(
 
             isComReceiver = (object)receiverNamedType != null && receiverNamedType.IsComImport;
 
-            if (!_inOperationContext)
+            if (factory != null)
             {
                 temporariesBuilder = ArrayBuilder<LocalSymbol>.GetInstance();
-                rewrittenArguments = _factory.MakeTempsForDiscardArguments(rewrittenArguments, temporariesBuilder);
+                rewrittenArguments = factory.MakeTempsForDiscardArguments(rewrittenArguments, temporariesBuilder);
             }
 
             return rewrittenArguments.Length == methodOrIndexer.GetParameterCount() &&
@@ -664,7 +663,7 @@ private void BuildStoresToTemps(
                     }
                 }
 
-                if (IsSafeForReordering(argument, refKind) || _inOperationContext)
+                if (IsSafeForReordering(argument, refKind))
                 {
                     arguments[p] = argument;
                     refKinds[p] = refKind;
@@ -680,12 +679,13 @@ private void BuildStoresToTemps(
         }
 
         // This fills in the arguments and parameters arrays in evaluation order.
-        private void BuildArgumentsInEvaluationOrder(
+        private static void BuildExplicitArgumentsInEvaluationOrder(
             SyntaxNode syntax,
             Symbol methodOrIndexer,
             bool expanded,
             ImmutableArray<int> argsToParamsOpt,
             ImmutableArray<BoundExpression> arguments,
+            CSharpCompilation compilation,
             /* out */ ArrayBuilder<BoundExpression> argumentsBuilder,
             /* out */ ArrayBuilder<ArgumentKind> argumentKindsBuilder,
             /* out */ ArrayBuilder<ParameterSymbol> parametersBuilder,
@@ -731,7 +731,7 @@ private void BuildArgumentsInEvaluationOrder(
                     var paramArrayType = parameters[p].Type;
                     var arrayArgs = paramArray.ToImmutableAndFree();
 
-                    argument = CreateParamArrayArgument(syntax, methodOrIndexer, paramArrayType, arrayArgs);
+                    argument = CreateParamArrayArgument(syntax, methodOrIndexer, paramArrayType, arrayArgs, compilation, null, false);
                 }
 
                 argumentsBuilder.Add(argument);
@@ -743,7 +743,7 @@ private void BuildArgumentsInEvaluationOrder(
             ParameterSymbol lastParameter;
             if (expanded && (lastParameter = parameters.Last()).IsParams && !processedPeremeters.Contains(parameters.Length - 1))
             {
-                var argument = CreateParamArrayArgument(syntax, methodOrIndexer, lastParameter.Type, ImmutableArray<BoundExpression>.Empty);
+                var argument = CreateParamArrayArgument(syntax, methodOrIndexer, lastParameter.Type, ImmutableArray<BoundExpression>.Empty, compilation, null, false);
 
                 argumentsBuilder.Add(argument);
                 argumentKindsBuilder.Add(ArgumentKind.ParamArray);
@@ -796,17 +796,12 @@ private BoundExpression BuildParamsArray(
 
             var paramArrayType = parameters[paramsParam].Type;
             var arrayArgs = paramArray.ToImmutableAndFree();
-            return CreateParamArrayArgument(syntax, methodOrIndexer, paramArrayType, arrayArgs);
-        }
-
-        private BoundExpression CreateParamArrayArgument(SyntaxNode syntax, Symbol methodOrIndexer, TypeSymbol paramArrayType, ImmutableArray<BoundExpression> arrayArgs)
-        {
 
             // If this is a zero-length array, rather than using "new T[0]", optimize with "Array.Empty<T>()" 
             // if it's available.  However, we also disable the optimization if we're in an expression lambda, the 
             // point of which is just to represent the semantics of an operation, and we don't know that all consumers
             // of expression lambdas will appropriately understand Array.Empty<T>().
-            if (arrayArgs.Length == 0 && !_inExpressionLambda && !_inOperationContext)
+            if (arrayArgs.Length == 0 && !_inExpressionLambda)
             {
                 ArrayTypeSymbol ats = paramArrayType as ArrayTypeSymbol;
                 if (ats != null) // could be null if there's a semantic error, e.g. the params parameter type isn't an array
@@ -834,12 +829,18 @@ private BoundExpression CreateParamArrayArgument(SyntaxNode syntax, Symbol metho
                 }
             }
 
-            var int32Type = methodOrIndexer.ContainingAssembly.GetPrimitiveType(Microsoft.Cci.PrimitiveTypeCode.Int32);
+            return CreateParamArrayArgument(syntax, methodOrIndexer, paramArrayType, arrayArgs, _compilation, _factory.CurrentMethod, _inExpressionLambda);
+        }
+
+        private static BoundExpression CreateParamArrayArgument(SyntaxNode syntax, Symbol methodOrIndexer, TypeSymbol paramArrayType, ImmutableArray<BoundExpression> arrayArgs, CSharpCompilation compilation, MethodSymbol currentMethod, bool inExpressionLambda)
+        {
+
+            var int32Type = methodOrIndexer.ContainingAssembly.GetSpecialType(SpecialType.System_Int32);
 
             return new BoundArrayCreation(
                 syntax,
                 ImmutableArray.Create(
-                    MakeLiteral(syntax, ConstantValue.Create(arrayArgs.Length), int32Type)),
+                    MakeLiteral(syntax, ConstantValue.Create(arrayArgs.Length), int32Type, compilation, currentMethod, inExpressionLambda)),
                 new BoundArrayInitialization(syntax, arrayArgs),
                 paramArrayType);
         }
@@ -990,8 +991,9 @@ private void InsertMissingOptionalArguments(SyntaxNode syntax,
             }
         }
 
-        private void AppendMissingOptionalArguments(SyntaxNode syntax,
+        private static void AppendMissingOptionalArguments(SyntaxNode syntax,
             ImmutableArray<ParameterSymbol> missingParameters,
+            Binder binder,
             ArrayBuilder<BoundExpression> argumentsBuilder,
             ArrayBuilder<ArgumentKind> argumentKindsBuilder,
             ArrayBuilder<ParameterSymbol> parametersBuilder,
@@ -1001,7 +1003,7 @@ private void AppendMissingOptionalArguments(SyntaxNode syntax,
             {
                 Debug.Assert(parameter.IsOptional);
 
-                var defaultArgument = GetDefaultParameterValue(syntax, parameter, enableCallerInfo);
+                var defaultArgument = GetDefaultParameterValue(syntax, parameter, enableCallerInfo, null, binder.Compilation, binder.ContainingMember(), new DiagnosticBag());
 
                 argumentsBuilder.Add(defaultArgument);
                 argumentKindsBuilder.Add(ArgumentKind.DefaultValue);
@@ -1067,9 +1069,36 @@ private static SourceLocation GetCallerLocation(SyntaxNode syntax, ThreeState en
         /// we will provide caller information as a value of this parameter.
         /// This is done to match the native compiler behavior and user requests (see http://roslyn.codeplex.com/workitem/171). This behavior
         /// does not match the C# spec that currently requires to provide caller information only in explicit invocations and query expressions.
-        /// </remarks>
+        /// </remarks>  
         private BoundExpression GetDefaultParameterValue(SyntaxNode syntax, ParameterSymbol parameter, ThreeState enableCallerInfo)
         {
+            return GetDefaultParameterValue(syntax, parameter, enableCallerInfo, this, null, null, null);
+        }
+
+        private static BoundExpression GetDefaultParameterValue(
+            SyntaxNode syntax, 
+            ParameterSymbol parameter,
+            ThreeState enableCallerInfo,
+            LocalRewriter localRewriter,
+            CSharpCompilation compilation,
+            Symbol containingMemberSymbol, 
+            DiagnosticBag diagnostics)
+        {
+            Debug.Assert(localRewriter == null ^ (compilation == null && containingMemberSymbol == null && diagnostics == null));
+
+            bool isLowering = false;
+            bool inExpressionLambda = false;
+            MethodSymbol currentMethod = null;
+
+            if (localRewriter != null)
+            {
+                isLowering = true;
+                compilation = localRewriter._compilation;
+                inExpressionLambda = localRewriter._inExpressionLambda;
+                currentMethod = localRewriter._factory.CurrentMethod;
+                diagnostics = localRewriter._diagnostics;
+            }
+
             // TODO: Ideally, the enableCallerInfo parameter would be of just bool type with only 'true' and 'false' values, and all callers
             // explicitly provided one of those values, so that we do not rely on shape of syntax nodes in the rewriter. There are not many immediate callers, 
             // but often the immediate caller does not have the required information, so all possible call chains should be analyzed and possibly updated
@@ -1091,57 +1120,46 @@ private BoundExpression GetDefaultParameterValue(SyntaxNode syntax, ParameterSym
             if (parameter.IsCallerLineNumber && ((callerSourceLocation = GetCallerLocation(syntax, enableCallerInfo)) != null))
             {
                 int line = callerSourceLocation.SourceTree.GetDisplayLineNumber(callerSourceLocation.SourceSpan);
+                                     
+                BoundExpression lineLiteral = MakeLiteral(syntax, ConstantValue.Create(line), compilation.GetSpecialType(SpecialType.System_Int32), compilation, currentMethod, inExpressionLambda);
 
-                if (_inOperationContext)
+                if (parameterType.IsNullableType())
                 {
-                    defaultValue = MakeLiteral(syntax, ConstantValue.Create(line), parameter.ContainingAssembly.GetSpecialType(SpecialType.System_Int32));
-                }
-                else
-                {
-                    BoundExpression lineLiteral = MakeLiteral(syntax, ConstantValue.Create(line), _compilation.GetSpecialType(SpecialType.System_Int32));
+                    TypeSymbol nullableType = parameterType.GetNullableUnderlyingType();
+                    defaultValue = isLowering
+                        ? localRewriter.MakeConversionNode(lineLiteral, nullableType, false)                
+                        : MakeConversionNodeIfNecessaryWithoutLowering(lineLiteral, nullableType, syntax, compilation, diagnostics, false); 
 
-                    if (parameterType.IsNullableType())
-                    {
-                        defaultValue = MakeConversionNode(lineLiteral, parameterType.GetNullableUnderlyingType(), false);
-
-                        // wrap it in a nullable ctor.
-                        defaultValue = new BoundObjectCreationExpression(
-                            syntax,
-                            UnsafeGetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
-                            null,
-                            defaultValue);
-                    }
-                    else
-                    {
-                        defaultValue = MakeConversionNode(lineLiteral, parameterType, false);
-                    }
+                    // wrap it in a nullable ctor.
+                    defaultValue = new BoundObjectCreationExpression(
+                        syntax,
+                        UnsafeGetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor, compilation, diagnostics),
+                        null,
+                        defaultValue);
                 }
+                else
+                {                                                                                                                                     
+                    defaultValue = isLowering
+                        ? localRewriter.MakeConversionNode(lineLiteral, parameterType, false)
+                        : MakeConversionNodeIfNecessaryWithoutLowering(lineLiteral, parameterType, syntax, compilation, diagnostics, false);
+                }  
             }
             else if (parameter.IsCallerFilePath && ((callerSourceLocation = GetCallerLocation(syntax, enableCallerInfo)) != null))
             {
-                if (_inOperationContext)
-                {
-                    string path = syntax.SyntaxTree.FilePath;
-                    defaultValue = MakeLiteral(syntax, ConstantValue.Create(path), parameter.ContainingAssembly.GetSpecialType(SpecialType.System_String));
-                }
-                else
-                {
-                    string path = callerSourceLocation.SourceTree.GetDisplayPath(callerSourceLocation.SourceSpan, _compilation.Options.SourceReferenceResolver);
-                    BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(path), _compilation.GetSpecialType(SpecialType.System_String));
-                    defaultValue = MakeConversionNode(memberNameLiteral, parameterType, false);
-                }
+                string path = callerSourceLocation.SourceTree.GetDisplayPath(callerSourceLocation.SourceSpan, compilation.Options.SourceReferenceResolver);
+                BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(path), compilation.GetSpecialType(SpecialType.System_String), compilation, currentMethod, inExpressionLambda); 
+                defaultValue = isLowering
+                    ? localRewriter.MakeConversionNode(memberNameLiteral, parameterType, false)
+                    : MakeConversionNodeIfNecessaryWithoutLowering(memberNameLiteral, parameterType, syntax, compilation, diagnostics, false);
             }
             else if (parameter.IsCallerMemberName && ((callerSourceLocation = GetCallerLocation(syntax, enableCallerInfo)) != null))
             {
-                if (_inOperationContext)
-                {
-                    defaultValue = MakeLiteral(syntax, ConstantValue.Create(string.Empty), parameter.ContainingAssembly.GetSpecialType(SpecialType.System_String));
-                }
-                else
-                {
-                    string memberName;
+                string memberName;
 
-                    switch (_factory.TopLevelMethod.MethodKind)
+                if (isLowering)
+                {
+                    MethodSymbol topLevelMethod = localRewriter._factory.TopLevelMethod;
+                    switch (topLevelMethod.MethodKind)
                     {
                         case MethodKind.Constructor:
                         case MethodKind.StaticConstructor:
@@ -1188,20 +1206,29 @@ private BoundExpression GetDefaultParameterValue(SyntaxNode syntax, ParameterSym
                             goto default;
 
                         default:
-                            memberName = _factory.TopLevelMethod.GetMemberCallerName();
+                            memberName = topLevelMethod.GetMemberCallerName();
                             break;
                     }
-                    BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(memberName), _compilation.GetSpecialType(SpecialType.System_String));
-                    defaultValue = MakeConversionNode(memberNameLiteral, parameterType, false);
                 }
+                else
+                {
+                    memberName = containingMemberSymbol.Name;
+                }
+
+                BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(memberName), compilation.GetSpecialType(SpecialType.System_String), compilation, currentMethod, inExpressionLambda);  
+                defaultValue = isLowering
+                    ? localRewriter.MakeConversionNode(memberNameLiteral, parameterType, false)
+                    : MakeConversionNodeIfNecessaryWithoutLowering(memberNameLiteral, parameterType, syntax, compilation, diagnostics, false);
             }
             else if (defaultConstantValue == ConstantValue.NotAvailable)
-            {
+            {                                                                                 
                 // There is no constant value given for the parameter in source/metadata.
-                if ((parameterType.IsDynamic() || parameterType.SpecialType == SpecialType.System_Object) && !_inOperationContext)
+                if (parameterType.IsDynamic() || parameterType.SpecialType == SpecialType.System_Object)
                 {
                     // We have something like M([Optional] object x). We have special handling for such situations.
-                    defaultValue = GetDefaultParameterSpecial(syntax, parameter);
+                    defaultValue = isLowering 
+                        ? localRewriter.GetDefaultParameterSpecial(syntax, parameter)
+                        : GetDefaultParameterSpecialWithOutLowering(syntax, parameter, compilation, diagnostics);
                 }
                 else
                 {
@@ -1220,54 +1247,55 @@ private BoundExpression GetDefaultParameterValue(SyntaxNode syntax, ParameterSym
                 // We have something like M(double? x = 1.23), so replace the argument
                 // with new double?(1.23).
 
-                if (_inOperationContext)
-                {
-                    defaultValue = MakeLiteral(syntax, defaultConstantValue, parameterType);
-                }
-                else
-                {
-                    TypeSymbol constantType = _compilation.GetSpecialType(defaultConstantValue.SpecialType);
-                    defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType);
+                TypeSymbol constantType = compilation.GetSpecialType(defaultConstantValue.SpecialType);
+                defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType, compilation, currentMethod, inExpressionLambda);
 
-                    // The parameter's underlying type might not match the constant type. For example, we might have
-                    // a default value of 5 (an integer) but a parameter type of decimal?.
+                // The parameter's underlying type might not match the constant type. For example, we might have
+                // a default value of 5 (an integer) but a parameter type of decimal?.
 
-                    defaultValue = MakeConversionNode(defaultValue, parameterType.GetNullableUnderlyingType(), @checked: false, acceptFailingConversion: true);
+                defaultValue = isLowering
+                    ? localRewriter.MakeConversionNode(defaultValue, parameterType.GetNullableUnderlyingType(), @checked: false, acceptFailingConversion: true)
+                    : MakeConversionNodeIfNecessaryWithoutLowering(defaultValue, parameterType.GetNullableUnderlyingType(), syntax, compilation, diagnostics, @checked: false, acceptFailingConversion: true);
 
-                    // Finally, wrap it in a nullable ctor.
-                    defaultValue = new BoundObjectCreationExpression(
-                        syntax,
-                        UnsafeGetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
-                        null,
-                        defaultValue);
-
-                }
+                // Finally, wrap it in a nullable ctor.
+                defaultValue = new BoundObjectCreationExpression(
+                    syntax,
+                    UnsafeGetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor, compilation, diagnostics),
+                    null,
+                    defaultValue); 
             }
             else if (defaultConstantValue.IsNull || defaultConstantValue.IsBad)
             {
-                defaultValue = MakeLiteral(syntax, defaultConstantValue, parameterType);
+                defaultValue = MakeLiteral(syntax, defaultConstantValue, parameterType, compilation, currentMethod, inExpressionLambda);
             }
             else
             {
                 // We have something like M(double x = 1.23), so replace the argument with 1.23.
 
-                if (_inOperationContext)
-                {
-                    defaultValue = MakeLiteral(syntax, defaultConstantValue, parameterType);
-                }
-                else
-                {
-                    TypeSymbol constantType = _compilation.GetSpecialType(defaultConstantValue.SpecialType);
-                    defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType);
-                    // The parameter type might not match the constant type.
-                    defaultValue = MakeConversionNode(defaultValue, parameterType, @checked: false, acceptFailingConversion: true);
-                }
+                TypeSymbol constantType = compilation.GetSpecialType(defaultConstantValue.SpecialType);
+                defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType, compilation, currentMethod, inExpressionLambda);
+                // The parameter type might not match the constant type.                                                                                                                    
+                defaultValue = isLowering
+                    ? localRewriter.MakeConversionNode(defaultValue, parameterType, @checked: false, acceptFailingConversion: true)
+                    : MakeConversionNodeIfNecessaryWithoutLowering(defaultValue, parameterType, syntax, compilation, diagnostics, @checked: false, acceptFailingConversion: true);
             }
 
             return defaultValue;
         }
 
         private BoundExpression GetDefaultParameterSpecial(SyntaxNode syntax, ParameterSymbol parameter)
+        {
+            BoundExpression defaultValue = GetDefaultParameterSpecialNoConversion(syntax, parameter, this._compilation);  
+            return MakeConversionNode(defaultValue, parameter.Type, @checked: false);
+        }
+
+        private static BoundExpression GetDefaultParameterSpecialWithOutLowering(SyntaxNode syntax, ParameterSymbol parameter, CSharpCompilation compilation, DiagnosticBag diagnostics)
+        {
+            BoundExpression defaultValue = GetDefaultParameterSpecialNoConversion(syntax, parameter, compilation);
+            return MakeConversionNodeIfNecessaryWithoutLowering(defaultValue, parameter.Type, syntax, compilation, diagnostics, @checked: false);
+        }
+
+        private static BoundExpression GetDefaultParameterSpecialNoConversion(SyntaxNode syntax, ParameterSymbol parameter, CSharpCompilation compilation)
         {
             // We have a call to a method M([Optional] object x) which omits the argument. The value we generate
             // for the argument depends on the presence or absence of other attributes. The rules are:
@@ -1290,25 +1318,23 @@ private BoundExpression GetDefaultParameterSpecial(SyntaxNode syntax, ParameterS
             else if (parameter.IsIUnknownConstant)
             {
                 // new UnknownWrapper(default(object))
-                var methodSymbol = (MethodSymbol)_compilation.GetWellKnownTypeMember(WellKnownMember.System_Runtime_InteropServices_UnknownWrapper__ctor);
+                var methodSymbol = (MethodSymbol)compilation.GetWellKnownTypeMember(WellKnownMember.System_Runtime_InteropServices_UnknownWrapper__ctor);
                 var argument = new BoundDefaultExpression(syntax, parameter.Type);
                 defaultValue = new BoundObjectCreationExpression(syntax, methodSymbol, null, argument);
             }
             else if (parameter.IsIDispatchConstant)
             {
                 // new DispatchWrapper(default(object))
-                var methodSymbol = (MethodSymbol)_compilation.GetWellKnownTypeMember(WellKnownMember.System_Runtime_InteropServices_DispatchWrapper__ctor);
+                var methodSymbol = (MethodSymbol)compilation.GetWellKnownTypeMember(WellKnownMember.System_Runtime_InteropServices_DispatchWrapper__ctor);
                 var argument = new BoundDefaultExpression(syntax, parameter.Type);
                 defaultValue = new BoundObjectCreationExpression(syntax, methodSymbol, null, argument);
             }
             else
             {
                 // Type.Missing
-                var fieldSymbol = (FieldSymbol)_compilation.GetWellKnownTypeMember(WellKnownMember.System_Type__Missing);
+                var fieldSymbol = (FieldSymbol)compilation.GetWellKnownTypeMember(WellKnownMember.System_Type__Missing);
                 defaultValue = new BoundFieldAccess(syntax, null, fieldSymbol, ConstantValue.NotAvailable);
-            }
-
-            defaultValue = MakeConversionNode(defaultValue, parameter.Type, @checked: false);
+            }                                                                                
 
             return defaultValue;
         }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
index 966bbf45537d6..a2395b76fb21f 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
@@ -456,10 +456,26 @@ private static bool NeedsChecked(TypeSymbol source, TypeSymbol target)
         /// The error will be suppressed only for conversions from <see cref="decimal"/> or <see cref="DateTime"/>.
         /// </remarks>
         private BoundExpression MakeConversionNode(BoundExpression rewrittenOperand, TypeSymbol rewrittenType, bool @checked, bool acceptFailingConversion = false)
+        {
+            Conversion conversion = MakeConversion(rewrittenOperand, rewrittenType, _compilation, _diagnostics, acceptFailingConversion);
+            if (!conversion.IsValid)
+            {
+                return _factory.NullOrDefault(rewrittenType);
+            }
+
+            return MakeConversionNode(rewrittenOperand.Syntax, rewrittenOperand, conversion, rewrittenType, @checked);
+        }
+
+        private static Conversion MakeConversion(
+            BoundExpression rewrittenOperand,
+            TypeSymbol rewrittenType,
+            CSharpCompilation compilation,
+            DiagnosticBag diagnostics,
+            bool acceptFailingConversion)
         {
             HashSet<DiagnosticInfo> useSiteDiagnostics = null;
-            Conversion conversion = _compilation.Conversions.ClassifyConversionFromType(rewrittenOperand.Type, rewrittenType, ref useSiteDiagnostics);
-            _diagnostics.Add(rewrittenOperand.Syntax, useSiteDiagnostics);
+            Conversion conversion = compilation.Conversions.ClassifyConversionFromType(rewrittenOperand.Type, rewrittenType, ref useSiteDiagnostics);
+            diagnostics.Add(rewrittenOperand.Syntax, useSiteDiagnostics);
 
             if (!conversion.IsValid)
             {
@@ -468,17 +484,45 @@ private BoundExpression MakeConversionNode(BoundExpression rewrittenOperand, Typ
                      rewrittenOperand.Type.SpecialType != SpecialType.System_DateTime)
                 {
                     // error CS0029: Cannot implicitly convert type '{0}' to '{1}'
-                    _diagnostics.Add(
+                    diagnostics.Add(
                         ErrorCode.ERR_NoImplicitConv,
                         rewrittenOperand.Syntax.Location,
                         rewrittenOperand.Type,
                         rewrittenType);
                 }
+            }
 
-                return _factory.NullOrDefault(rewrittenType);
+            return conversion;
+        } 
+
+        private static BoundExpression MakeConversionNodeIfNecessaryWithoutLowering(
+            BoundExpression operand, 
+            TypeSymbol type, 
+            SyntaxNode syntax, 
+            CSharpCompilation compilation, 
+            DiagnosticBag diagnostics, 
+            bool @checked, 
+            bool acceptFailingConversion = false)
+        {
+            if (operand.Type.Equals(type))
+            {
+                return operand;
             }
+            Conversion conversion = MakeConversion(operand, type, compilation, diagnostics, acceptFailingConversion); 
 
-            return MakeConversionNode(rewrittenOperand.Syntax, rewrittenOperand, conversion, rewrittenType, @checked);
+            if (!conversion.IsValid)
+            {
+                return SyntheticBoundNodeFactory.NullOrDefault(type, syntax);
+            }
+
+            return new BoundConversion(
+                            syntax,
+                            operand,
+                            conversion,             
+                            @checked: @checked,
+                            explicitCastInCode: false,
+                            constantValueOpt: default(ConstantValue),
+                            type: type);
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs
index d8ba8ef9e36a3..640db515274aa 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs
@@ -17,6 +17,16 @@ public override BoundNode VisitLiteral(BoundLiteral node)
         }
 
         private BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue constantValue, TypeSymbol type, BoundLiteral oldNodeOpt = null)
+        {
+            return MakeLiteral(syntax, constantValue, type, _compilation, _factory.CurrentMethod, _inExpressionLambda, oldNodeOpt);
+        }
+
+        private static BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue constantValue, TypeSymbol type, CSharpCompilation compilation, MethodSymbol currentMethod, bool inExpressionLambda)
+        {
+            return MakeLiteral(syntax, constantValue, type, compilation, currentMethod, inExpressionLambda, null);
+        }
+
+        private static BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue constantValue, TypeSymbol type, CSharpCompilation compilation, MethodSymbol currentMethod, bool inExpressionLambda, BoundLiteral oldNodeOpt)
         {
             Debug.Assert(constantValue != null);
 
@@ -26,7 +36,7 @@ private BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue constantVal
                 Debug.Assert((object)type != null);
                 Debug.Assert(type.SpecialType == SpecialType.System_Decimal);
 
-                return MakeDecimalLiteral(syntax, constantValue);
+                return MakeDecimalLiteral(syntax, constantValue, compilation, currentMethod, inExpressionLambda);
             }
             else if (constantValue.IsDateTime)
             {
@@ -35,7 +45,7 @@ private BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue constantVal
                 // for its default value.
                 Debug.Assert((object)type != null);
                 Debug.Assert(type.SpecialType == SpecialType.System_DateTime);
-                return MakeDateTimeLiteral(syntax, constantValue);
+                return MakeDateTimeLiteral(syntax, constantValue, compilation);
             }
             else if (oldNodeOpt != null)
             {
@@ -47,7 +57,7 @@ private BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue constantVal
             }
         }
 
-        private BoundExpression MakeDecimalLiteral(SyntaxNode syntax, ConstantValue constantValue)
+        private static BoundExpression MakeDecimalLiteral(SyntaxNode syntax, ConstantValue constantValue, CSharpCompilation compilation, MethodSymbol currentMethod, bool inExpressionLambda)
         {
             Debug.Assert(constantValue != null);
             Debug.Assert(constantValue.IsDecimal);
@@ -62,28 +72,27 @@ private BoundExpression MakeDecimalLiteral(SyntaxNode syntax, ConstantValue cons
             SpecialMember member;
 
             // check if we can call a simpler constructor, or use a predefined constant
-            if (scale == 0 && int.MinValue <= value && value <= int.MaxValue)
+            if (scale == 0 && int.MinValue <= value && value <= int.MaxValue && currentMethod != null)
             {
                 // If we are building static constructor of System.Decimal, accessing static fields 
                 // would be bad.
-                var curMethod = _factory.CurrentMethod;
-                if ((curMethod.MethodKind != MethodKind.SharedConstructor ||
-                   curMethod.ContainingType.SpecialType != SpecialType.System_Decimal) &&
-                   !_inExpressionLambda)
+                if ((currentMethod.MethodKind != MethodKind.SharedConstructor ||
+                   currentMethod.ContainingType.SpecialType != SpecialType.System_Decimal) &&
+                   !inExpressionLambda)
                 {
                     Symbol useField = null;
 
                     if (value == decimal.Zero)
                     {
-                        useField = _compilation.GetSpecialTypeMember(SpecialMember.System_Decimal__Zero);
+                        useField = compilation.GetSpecialTypeMember(SpecialMember.System_Decimal__Zero);
                     }
                     else if (value == decimal.One)
                     {
-                        useField = _compilation.GetSpecialTypeMember(SpecialMember.System_Decimal__One);
+                        useField = compilation.GetSpecialTypeMember(SpecialMember.System_Decimal__One);
                     }
                     else if (value == decimal.MinusOne)
                     {
-                        useField = _compilation.GetSpecialTypeMember(SpecialMember.System_Decimal__MinusOne);
+                        useField = compilation.GetSpecialTypeMember(SpecialMember.System_Decimal__MinusOne);
                     }
 
                     if ((object)useField != null &&
@@ -97,38 +106,38 @@ private BoundExpression MakeDecimalLiteral(SyntaxNode syntax, ConstantValue cons
 
                 //new decimal(int);
                 member = SpecialMember.System_Decimal__CtorInt32;
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((int)value), _compilation.GetSpecialType(SpecialType.System_Int32)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((int)value), compilation.GetSpecialType(SpecialType.System_Int32)));
             }
             else if (scale == 0 && uint.MinValue <= value && value <= uint.MaxValue)
             {
                 //new decimal(uint);
                 member = SpecialMember.System_Decimal__CtorUInt32;
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((uint)value), _compilation.GetSpecialType(SpecialType.System_UInt32)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((uint)value), compilation.GetSpecialType(SpecialType.System_UInt32)));
             }
             else if (scale == 0 && long.MinValue <= value && value <= long.MaxValue)
             {
                 //new decimal(long);
                 member = SpecialMember.System_Decimal__CtorInt64;
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((long)value), _compilation.GetSpecialType(SpecialType.System_Int64)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((long)value), compilation.GetSpecialType(SpecialType.System_Int64)));
             }
             else if (scale == 0 && ulong.MinValue <= value && value <= ulong.MaxValue)
             {
                 //new decimal(ulong);
                 member = SpecialMember.System_Decimal__CtorUInt64;
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((ulong)value), _compilation.GetSpecialType(SpecialType.System_UInt64)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((ulong)value), compilation.GetSpecialType(SpecialType.System_UInt64)));
             }
             else
             {
                 //new decimal(int low, int mid, int high, bool isNegative, byte scale);
                 member = SpecialMember.System_Decimal__CtorInt32Int32Int32BooleanByte;
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(low), _compilation.GetSpecialType(SpecialType.System_Int32)));
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(mid), _compilation.GetSpecialType(SpecialType.System_Int32)));
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(high), _compilation.GetSpecialType(SpecialType.System_Int32)));
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(isNegative), _compilation.GetSpecialType(SpecialType.System_Boolean)));
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(scale), _compilation.GetSpecialType(SpecialType.System_Byte)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(low), compilation.GetSpecialType(SpecialType.System_Int32)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(mid), compilation.GetSpecialType(SpecialType.System_Int32)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(high), compilation.GetSpecialType(SpecialType.System_Int32)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(isNegative), compilation.GetSpecialType(SpecialType.System_Boolean)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(scale), compilation.GetSpecialType(SpecialType.System_Byte)));
             }
 
-            var ctor = (MethodSymbol)_compilation.Assembly.GetSpecialTypeMember(member);
+            var ctor = (MethodSymbol)compilation.Assembly.GetSpecialTypeMember(member);
             Debug.Assert((object)ctor != null);
             Debug.Assert(ctor.ContainingType.SpecialType == SpecialType.System_Decimal);
 
@@ -138,15 +147,15 @@ private BoundExpression MakeDecimalLiteral(SyntaxNode syntax, ConstantValue cons
                 constantValue, null, null, ctor.ContainingType);
         }
 
-        private BoundExpression MakeDateTimeLiteral(SyntaxNode syntax, ConstantValue constantValue)
+        private static BoundExpression MakeDateTimeLiteral(SyntaxNode syntax, ConstantValue constantValue, CSharpCompilation compilation)
         {
             Debug.Assert(constantValue != null);
             Debug.Assert(constantValue.IsDateTime);
 
             var arguments = new ArrayBuilder<BoundExpression>();
-            arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(constantValue.DateTimeValue.Ticks), _compilation.GetSpecialType(SpecialType.System_Int64)));
+            arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(constantValue.DateTimeValue.Ticks), compilation.GetSpecialType(SpecialType.System_Int64)));
 
-            var ctor = (MethodSymbol)_compilation.Assembly.GetSpecialTypeMember(SpecialMember.System_DateTime__CtorInt64);
+            var ctor = (MethodSymbol)compilation.Assembly.GetSpecialTypeMember(SpecialMember.System_DateTime__CtorInt64);
             Debug.Assert((object)ctor != null);
             Debug.Assert(ctor.ContainingType.SpecialType == SpecialType.System_DateTime);
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
index e0e09cccab16d..317919972b1ac 100644
--- a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
@@ -165,12 +165,6 @@ public SyntheticBoundNodeFactory(MethodSymbol topLevelMethodOpt, NamedTypeSymbol
             this.CurrentType = currentClassOpt;
             this.Syntax = node;
             this.Diagnostics = diagnostics;
-        }                                                                                
-
-        public SyntheticBoundNodeFactory(SyntaxNode node, DiagnosticBag diagnostics)
-        {                                          
-            this.Syntax = node;
-            this.Diagnostics = diagnostics;
         }
 
         [Conditional("DEBUG")]
@@ -962,9 +956,14 @@ public BoundExpression ThrowExpression(BoundExpression thrown, TypeSymbol type)
 
         public BoundExpression Null(TypeSymbol type)
         {
-            BoundExpression nullLiteral = new BoundLiteral(Syntax, ConstantValue.Null, type) { WasCompilerGenerated = true };
+            return Null(type, Syntax);
+        }
+
+        public static BoundExpression Null(TypeSymbol type, SyntaxNode syntax)
+        {
+            BoundExpression nullLiteral = new BoundLiteral(syntax, ConstantValue.Null, type) { WasCompilerGenerated = true };
             return type.IsPointerType()
-                ? BoundConversion.SynthesizedNonUserDefined(Syntax, nullLiteral, Conversion.NullToPointer, type)
+                ? BoundConversion.SynthesizedNonUserDefined(syntax, nullLiteral, Conversion.NullToPointer, type)
                 : nullLiteral;
         }
 
@@ -1188,7 +1187,12 @@ public BoundExpression Array(TypeSymbol elementType, BoundExpression length)
 
         internal BoundExpression Default(TypeSymbol type)
         {
-            return new BoundDefaultExpression(Syntax, type) { WasCompilerGenerated = true };
+            return Default(type, Syntax);
+        }
+
+        internal static BoundExpression Default(TypeSymbol type, SyntaxNode syntax)
+        {
+            return new BoundDefaultExpression(syntax, type) { WasCompilerGenerated = true };
         }
 
         internal BoundStatement Try(
@@ -1227,7 +1231,12 @@ internal BoundTryStatement Fault(BoundBlock tryBlock, BoundBlock faultBlock)
 
         internal BoundExpression NullOrDefault(TypeSymbol typeSymbol)
         {
-            return typeSymbol.IsValueType ? Default(typeSymbol) : Null(typeSymbol);
+            return NullOrDefault(typeSymbol, this.Syntax);
+        }
+
+        internal static BoundExpression NullOrDefault(TypeSymbol typeSymbol, SyntaxNode syntax)
+        {
+            return typeSymbol.IsValueType ? Default(typeSymbol, syntax) : Null(typeSymbol, syntax);
         }
 
         internal BoundExpression Not(
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index 9fdc714a5b091..4db77deb3981b 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -757,7 +757,7 @@ Element Values(1): IConversionExpression (ConversionKind.CSharp, Implicit) (Oper
         }
 
         [Fact]
-        public void CallerInfoAttributes()
+        public void CallerInfoAttributesInvokedInMethod()
         {
             string source = @"
 using System.Runtime.CompilerServices;
@@ -780,17 +780,84 @@ void M2(
 IInvocationExpression ( void P.M2([System.String memberName = null], [System.String sourceFilePath = null], [System.Int32 sourceLineNumber = 0])) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'M2()')
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
   Arguments(3): IArgument (ArgumentKind.DefaultValue, Matching Parameter: memberName) (OperationKind.Argument) (Syntax: 'M2()')
-      ILiteralExpression (Text: ) (OperationKind.LiteralExpression, Type: System.String, Constant: """") (Syntax: 'M2()')
-    IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceFilePath) (OperationKind.Argument) (Syntax: 'M2()')
-      ILiteralExpression (Text: ) (OperationKind.LiteralExpression, Type: System.String, Constant: """") (Syntax: 'M2()')
-    IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceLineNumber) (OperationKind.Argument) (Syntax: 'M2()')
-      ILiteralExpression (Text: 8) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 8) (Syntax: 'M2()')
+      ILiteralExpression (Text: M1) (OperationKind.LiteralExpression, Type: System.String, Constant: ""M1"") (Syntax: 'M2()')
+    IArgument(ArgumentKind.DefaultValue, Matching Parameter: sourceFilePath)(OperationKind.Argument)(Syntax: 'M2()')
+      ILiteralExpression(Text: )(OperationKind.LiteralExpression, Type: System.String, Constant: """")(Syntax: 'M2()')
+    IArgument(ArgumentKind.DefaultValue, Matching Parameter: sourceLineNumber)(OperationKind.Argument)(Syntax: 'M2()')
+      ILiteralExpression(Text: 8)(OperationKind.LiteralExpression, Type: System.Int32, Constant: 8)(Syntax: 'M2()')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
+        [Fact]
+        public void CallerInfoAttributesInvokedInProperty()
+        {
+            string source = @"
+using System.Runtime.CompilerServices;
+
+class P
+{
+    bool M1 => /*<bind>*/M2()/*</bind>*/;
+
+    bool M2(
+        [CallerMemberName] string memberName = null,
+        [CallerFilePath] string sourceFilePath = null,
+        [CallerLineNumber] int sourceLineNumber = 0)
+    { 
+        return true;
+    }
+}
+";
+            string expectedOperationTree = @"
+IInvocationExpression ( System.Boolean P.M2([System.String memberName = null], [System.String sourceFilePath = null], [System.Int32 sourceLineNumber = 0])) (OperationKind.InvocationExpression, Type: System.Boolean) (Syntax: 'M2()')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
+  Arguments(3): IArgument (ArgumentKind.DefaultValue, Matching Parameter: memberName) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (Text: get_M1) (OperationKind.LiteralExpression, Type: System.String, Constant: ""get_M1"") (Syntax: 'M2()')
+    IArgument(ArgumentKind.DefaultValue, Matching Parameter: sourceFilePath)(OperationKind.Argument)(Syntax: 'M2()')
+      ILiteralExpression(Text: )(OperationKind.LiteralExpression, Type: System.String, Constant: """")(Syntax: 'M2()')
+    IArgument(ArgumentKind.DefaultValue, Matching Parameter: sourceLineNumber)(OperationKind.Argument)(Syntax: 'M2()')
+      ILiteralExpression(Text: 6)(OperationKind.LiteralExpression, Type: System.Int32, Constant: 6)(Syntax: 'M2()')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [Fact]
+        public void CallerInfoAttributesInvokedInFieldInitilizer()
+        {
+            string source = @"
+using System.Runtime.CompilerServices;
+
+class P
+{
+    bool field = /*<bind>*/M2()/*</bind>*/;
+
+    static bool M2(
+        [CallerMemberName] string memberName = null,
+        [CallerFilePath] string sourceFilePath = null,
+        [CallerLineNumber] int sourceLineNumber = 0)
+    {
+        return true;
+    }
+}
+";
+            string expectedOperationTree = @"
+IInvocationExpression (static System.Boolean P.M2([System.String memberName = null], [System.String sourceFilePath = null], [System.Int32 sourceLineNumber = 0])) (OperationKind.InvocationExpression, Type: System.Boolean) (Syntax: 'M2()')
+  Arguments(3): IArgument (ArgumentKind.DefaultValue, Matching Parameter: memberName) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (Text: field) (OperationKind.LiteralExpression, Type: System.String, Constant: ""field"") (Syntax: 'M2()')
+    IArgument(ArgumentKind.DefaultValue, Matching Parameter: sourceFilePath)(OperationKind.Argument)(Syntax: 'M2()')
+      ILiteralExpression(Text: )(OperationKind.LiteralExpression, Type: System.String, Constant: """")(Syntax: 'M2()')
+    IArgument(ArgumentKind.DefaultValue, Matching Parameter: sourceLineNumber)(OperationKind.Argument)(Syntax: 'M2()')
+      ILiteralExpression(Text: 6)(OperationKind.LiteralExpression, Type: System.Int32, Constant: 6)(Syntax: 'M2()')"
+;
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
         [Fact]
         public void ExtraArgument()
         {
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IIfStatement.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IIfStatement.cs
index 862397adaf8b0..c355d43e5bbf6 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IIfStatement.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IIfStatement.cs
@@ -436,7 +436,7 @@ private void A(bool flag)
 ";
             string expectedOperationTree = @"
 IIfStatement (OperationKind.IfStatement) (Syntax: 'if (true) ... }')
-  Condition: ILiteralExpression (OperationKind.LiteralExpression, Type: System.Boolean, Constant: True) (Syntax: 'true')
+  Condition: ILiteralExpression (Text: True) (OperationKind.LiteralExpression, Type: System.Boolean, Constant: True) (Syntax: 'true')
   IfTrue: IBlockStatement (1 statements, 1 locals) (OperationKind.BlockStatement) (Syntax: '{ ... }')
       Locals: Local_1: System.Int32 i
       IExpressionStatement (OperationKind.ExpressionStatement) (Syntax: 'A(int.TryPa ... ut var i));')

From 7516025f41c53984013ba5f46a114ab5df628189 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Sat, 6 May 2017 20:48:41 -0700
Subject: [PATCH 164/284] Fix call to BoundObjectCreationExpression constructor
 in EE

---
 .../CSharp/Source/ExpressionCompiler/CompilationContext.cs      | 2 +-
 .../ExpressionCompiler/Rewriters/LocalDeclarationRewriter.cs    | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CompilationContext.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CompilationContext.cs
index 670b10b063e16..5dee62b0c0f19 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CompilationContext.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CompilationContext.cs
@@ -566,7 +566,7 @@ private EEMethodSymbol GetTypeVariablesMethod(EENamedTypeSymbol container, strin
             {
                 declaredLocals = ImmutableArray<LocalSymbol>.Empty;
                 var type = method.TypeMap.SubstituteNamedType(typeVariablesType);
-                var expression = new BoundObjectCreationExpression(syntax, type.InstanceConstructors[0]);
+                var expression = new BoundObjectCreationExpression(syntax, type.InstanceConstructors[0], null);
                 var statement = new BoundReturnStatement(syntax, RefKind.None, expression) { WasCompilerGenerated = true };
                 properties = default(ResultProperties);
                 return statement;
diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Rewriters/LocalDeclarationRewriter.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Rewriters/LocalDeclarationRewriter.cs
index f02eea5112eca..8eb64a9340774 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Rewriters/LocalDeclarationRewriter.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Rewriters/LocalDeclarationRewriter.cs
@@ -125,6 +125,7 @@ private static BoundExpression GetCustomTypeInfoPayloadId(SyntaxNode syntax, Met
             return new BoundObjectCreationExpression(
                 syntax,
                 guidConstructor,
+                null,
                 new BoundLiteral(syntax, value, guidConstructor.ContainingType));
         }
 

From 9b75d0add655fc3537f1d80df82ad59eeba0a7de Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Sat, 6 May 2017 23:39:22 -0700
Subject: [PATCH 165/284] Fix IArgument and ArgumentsInEvaluationOrder related
 tests

---
 .../CSharp/Portable/BoundTree/Expression.cs   | 11 +---
 .../Diagnostics/OperationAnalyzerTests.cs     | 57 +++++++-----------
 .../IOperation/IOperationTests_IArgument.cs   | 60 +++++++++----------
 .../IOperationTests_IIfStatement.cs           |  2 +-
 .../Utilities/CSharp/SemanticModelTestBase.cs |  2 +-
 5 files changed, 55 insertions(+), 77 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index c631755d66d1f..322f4a54b94b2 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -353,16 +353,7 @@ public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, T
 
     internal partial class BoundLiteral : ILiteralExpression
     {
-        string ILiteralExpression.Text
-        {
-            get
-            {
-                object value;
-                return ((ILiteralExpression)this).ConstantValue.HasValue 
-                    ? ((value = this.ConstantValue.Value) == null ? "null" : value.ToString()) 
-                    : this.Syntax.ToString();
-            }
-        }
+        string ILiteralExpression.Text => this.Syntax.ToString();
 
         protected override OperationKind ExpressionKind => OperationKind.LiteralExpression;
 
diff --git a/src/Compilers/CSharp/Test/Semantic/Diagnostics/OperationAnalyzerTests.cs b/src/Compilers/CSharp/Test/Semantic/Diagnostics/OperationAnalyzerTests.cs
index 12e9092423c22..edf72ded92dbf 100644
--- a/src/Compilers/CSharp/Test/Semantic/Diagnostics/OperationAnalyzerTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Diagnostics/OperationAnalyzerTests.cs
@@ -280,7 +280,7 @@ public void M1(int x, int y)
                 Diagnostic(SwitchTestAnalyzer.NoDefaultSwitchDescriptor.Id, "y").WithLocation(40, 17));
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void InvocationCSharp()
         {
             const string source = @"
@@ -337,10 +337,6 @@ public void M6()
             CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularWithIOperationFeature)
             .VerifyDiagnostics()
             .VerifyAnalyzerDiagnostics(new DiagnosticAnalyzer[] { new InvocationTestAnalyzer() }, null, null, false,
-                Diagnostic(InvocationTestAnalyzer.OutOfNumericalOrderArgumentsDescriptor.Id, "2").WithLocation(16, 21),
-                Diagnostic(InvocationTestAnalyzer.OutOfNumericalOrderArgumentsDescriptor.Id, "1").WithLocation(17, 15),
-                Diagnostic(InvocationTestAnalyzer.OutOfNumericalOrderArgumentsDescriptor.Id, "2").WithLocation(17, 21),
-                Diagnostic(InvocationTestAnalyzer.OutOfNumericalOrderArgumentsDescriptor.Id, "4").WithLocation(17, 33),
                 Diagnostic(InvocationTestAnalyzer.BigParamArrayArgumentsDescriptor.Id, "M0(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)").WithLocation(19, 9),
                 Diagnostic(InvocationTestAnalyzer.BigParamArrayArgumentsDescriptor.Id, "M0(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)").WithLocation(20, 9),
                 Diagnostic(InvocationTestAnalyzer.OutOfNumericalOrderArgumentsDescriptor.Id, "3").WithLocation(23, 21),
@@ -753,7 +749,7 @@ interface IDerived : IMiddle, IBase2
                 );
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void ValueContextsCSharp()
         {
             const string source = @"
@@ -1167,7 +1163,7 @@ private void Mumbler(object sender, System.EventArgs args)
                 );
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact]
         public void ParamsArraysCSharp()
         {
             const string source = @"
@@ -1213,17 +1209,13 @@ public D(string a, params int[] b)
 ";
             CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularWithIOperationFeature)
             .VerifyDiagnostics()
-            .VerifyAnalyzerDiagnostics(new DiagnosticAnalyzer[] { new ParamsArrayTestAnalyzer() }, null, null, false,
-                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "2").WithLocation(13, 15),
-                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "2").WithLocation(13, 15),
-                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "2").WithLocation(14, 15),
-                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "2").WithLocation(14, 15),
-                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "new int[] { 2, 3, 4, 5 }").WithLocation(16, 15),
-                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "new int[] { 2, 3, 4, 5 }").WithLocation(16, 15),
-                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "new int[] { 2, 3, 4, 5, 6 }").WithLocation(17, 15),
-                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "new int[] { 2, 3, 4, 5, 6 }").WithLocation(17, 15),
-                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "1").WithLocation(20, 28),
-                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "new int[] { 1, 2, 3, 4 }").WithLocation(21, 28)
+            .VerifyAnalyzerDiagnostics(new DiagnosticAnalyzer[] { new ParamsArrayTestAnalyzer() }, null, null, false, 
+                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "M0(1, 2, 3, 4, 5)").WithLocation(13, 9),
+                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "M0(1, 2, 3, 4, 5, 6)").WithLocation(14, 9),
+                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "new int[] { 2, 3, 4, 5 }"),
+                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "new int[] { 2, 3, 4, 5, 6 }"),
+                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, @"new D(""Hello"", 1, 2, 3, 4)").WithLocation(20, 13),
+                Diagnostic(ParamsArrayTestAnalyzer.LongParamsDescriptor.Id, "new int[] { 1, 2, 3, 4 }")
                 );
         }
 
@@ -1623,10 +1615,9 @@ static void Main()
                  Diagnostic(OperatorPropertyPullerTestAnalyzer.BinaryOperatorDescriptor.Id, "x + 10").WithArguments("Invalid").WithLocation(29, 13),
                  Diagnostic(OperatorPropertyPullerTestAnalyzer.UnaryOperatorDescriptor.Id, "-x").WithArguments("Invalid").WithLocation(31, 13)
                  );
-        }
-
-        [WorkItem(8520, "https://github.com/dotnet/roslyn/issues/8520")]
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        } 
+        
+        [Fact, WorkItem(8520, "https://github.com/dotnet/roslyn/issues/8520")]
         public void NullOperationSyntaxCSharp()
         {
             const string source = @"
@@ -1650,9 +1641,9 @@ public void M1()
             CreateCompilationWithMscorlib45(source, parseOptions: TestOptions.RegularWithIOperationFeature)
             .VerifyDiagnostics()
             .VerifyAnalyzerDiagnostics(new DiagnosticAnalyzer[] { new NullOperationSyntaxTestAnalyzer() }, null, null, false,
-                Diagnostic(NullOperationSyntaxTestAnalyzer.ParamsArrayOperationDescriptor.Id, "M0()").WithLocation(10, 9),
-                Diagnostic(NullOperationSyntaxTestAnalyzer.ParamsArrayOperationDescriptor.Id, "1").WithLocation(11, 12),
-                Diagnostic(NullOperationSyntaxTestAnalyzer.ParamsArrayOperationDescriptor.Id, "1").WithLocation(12, 12));
+                Diagnostic(NullOperationSyntaxTestAnalyzer.ParamsArrayOperationDescriptor.Id, "M0()"),
+                Diagnostic(NullOperationSyntaxTestAnalyzer.ParamsArrayOperationDescriptor.Id, "M0(1)").WithLocation(11, 9),
+                Diagnostic(NullOperationSyntaxTestAnalyzer.ParamsArrayOperationDescriptor.Id, "M0(1, 2)").WithLocation(12, 9));
         }
 
         [WorkItem(9113, "https://github.com/dotnet/roslyn/issues/9113")]
@@ -1724,7 +1715,7 @@ public void Increment(string f)
                 Diagnostic(InvalidOperatorExpressionTestAnalyzer.InvalidIncrementDescriptor.Id, "f++").WithLocation(16, 9));
         }
         
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549"), WorkItem(9114, "https://github.com/dotnet/roslyn/issues/9114")]
+        [Fact, WorkItem(9114, "https://github.com/dotnet/roslyn/issues/9114")]
         public void InvalidArgumentCSharp()
         {
             const string source = @"
@@ -1748,9 +1739,7 @@ public static int Main()
                 // (8,9): error CS7036: There is no argument given that corresponds to the required formal parameter 'a' of 'A.Foo(params int)'
                 //         Foo();
                 Diagnostic(ErrorCode.ERR_NoCorrespondingArgument, "Foo").WithArguments("a", "A.Foo(params int)").WithLocation(8, 9))
-            .VerifyAnalyzerDiagnostics(new DiagnosticAnalyzer[] { new InvocationTestAnalyzer() }, null, null, false,
-                Diagnostic(InvocationTestAnalyzer.InvalidArgumentDescriptor.Id, "Foo()").WithLocation(8, 9),
-                Diagnostic(InvocationTestAnalyzer.InvalidArgumentDescriptor.Id, "Foo(1)").WithLocation(9, 9));
+            .VerifyAnalyzerDiagnostics(new DiagnosticAnalyzer[] { new InvocationTestAnalyzer() }, null, null, false);
         }
 
         [Fact]
@@ -1812,8 +1801,7 @@ public void M0(C p)
                 Diagnostic(ConditionalAccessOperationTestAnalyzer.ConditionalAccessInstanceOperationDescriptor.Id, "Field1").WithLocation(32, 9));
         }
 
-        [WorkItem(9116, "https://github.com/dotnet/roslyn/issues/9116")]
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18549")]
+        [Fact, WorkItem(9116, "https://github.com/dotnet/roslyn/issues/9116")]
         public void LiteralCSharp()
         {
             const string source = @"
@@ -1844,10 +1832,9 @@ void M(
                 Diagnostic("Literal", "1").WithArguments("1").WithLocation(13, 17),
                 Diagnostic("Literal", @"""hello""").WithArguments(@"""hello""").WithLocation(14, 22),
                 Diagnostic("Literal", "null").WithArguments("null").WithLocation(15, 20),
-                Diagnostic("Literal", "M()").WithArguments("1").WithLocation(18, 9),
-                Diagnostic("Literal", "M()").WithArguments(@"""hello""").WithLocation(18, 9),
-                Diagnostic("Literal", "M()").WithArguments("null").WithLocation(18, 9),
-                Diagnostic("Literal", "M()").WithArguments("null").WithLocation(18, 9));
+                Diagnostic("Literal", "M()").WithArguments("M()").WithLocation(18, 9),
+                Diagnostic("Literal", "M()").WithArguments("M()").WithLocation(18, 9),
+                Diagnostic("Literal", "M()").WithArguments("M()").WithLocation(18, 9));
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index 4db77deb3981b..bda935a0f1033 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -27,7 +27,7 @@ static void M2(int x, double y) { }
   Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '1')
       ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
     IArgument (ArgumentKind.Explicit, Matching Parameter: y) (OperationKind.Argument) (Syntax: '2.0')
-      ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Double, Constant: 2) (Syntax: '2.0')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Double, Constant: 2) (Syntax: '2.0')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
@@ -53,7 +53,7 @@ static void M2(int x, double y = 0.0) { }
   Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '1')
       ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
     IArgument (ArgumentKind.DefaultValue, Matching Parameter: y) (OperationKind.Argument) (Syntax: 'M2(1)')
-      ILiteralExpression (Text: 0) (OperationKind.LiteralExpression, Type: System.Double, Constant: 0) (Syntax: 'M2(1)')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Double, Constant: 0) (Syntax: 'M2(1)')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
@@ -160,7 +160,7 @@ static void M2(int x = 1, int y = 2, int z = 3) { }
     IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '9')
       ILiteralExpression (Text: 9) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 9) (Syntax: '9')
     IArgument (ArgumentKind.DefaultValue, Matching Parameter: y) (OperationKind.Argument) (Syntax: 'M2(z: 2, x: 9)')
-      ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: 'M2(z: 2, x: 9)')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: 'M2(z: 2, x: 9)')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
@@ -189,7 +189,7 @@ static void M2(int x = 1, int y = 2, int z = 3) { }
       IArgument (ArgumentKind.Explicit, Matching Parameter: z) (OperationKind.Argument) (Syntax: '10')
         ILiteralExpression (Text: 10) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 10) (Syntax: '10')
       IArgument (ArgumentKind.DefaultValue, Matching Parameter: y) (OperationKind.Argument) (Syntax: 'M2(9, z: 10)')
-        ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: 'M2(9, z: 10)')
+        ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: 'M2(9, z: 10)')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
@@ -356,7 +356,7 @@ void M2(double s = Pi) { }
 IInvocationExpression ( void P.M2([System.Double s = 3.14])) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'M2()')
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
   Arguments(1): IArgument (ArgumentKind.DefaultValue, Matching Parameter: s) (OperationKind.Argument) (Syntax: 'M2()')
-      ILiteralExpression (Text: 3.14) (OperationKind.LiteralExpression, Type: System.Double, Constant: 3.14) (Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Double, Constant: 3.14) (Syntax: 'M2()')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
@@ -453,7 +453,7 @@ public static void E1(this P p, int x = 0, int y = 0)
     IArgument (ArgumentKind.Explicit, Matching Parameter: y) (OperationKind.Argument) (Syntax: '1')
       ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
     IArgument (ArgumentKind.DefaultValue, Matching Parameter: x) (OperationKind.Argument) (Syntax: 'this.E1(y: 1)')
-      ILiteralExpression (Text: 0) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: 'this.E1(y: 1)')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: 'this.E1(y: 1)')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
@@ -509,7 +509,7 @@ void M2(int x, params double[] array) { }
       ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
     IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: 'M2(1, 0.1, 0.2)')
       IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: 'M2(1, 0.1, 0.2)')
-        Dimension Sizes(1): ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: 'M2(1, 0.1, 0.2)')
+        Dimension Sizes(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: 'M2(1, 0.1, 0.2)')
         Initializer: IArrayInitializer (2 elements) (OperationKind.ArrayInitializer) (Syntax: 'M2(1, 0.1, 0.2)')
             Element Values(2): ILiteralExpression (Text: 0.1) (OperationKind.LiteralExpression, Type: System.Double, Constant: 0.1) (Syntax: '0.1')
               ILiteralExpression (Text: 0.2) (OperationKind.LiteralExpression, Type: System.Double, Constant: 0.2) (Syntax: '0.2')
@@ -540,7 +540,7 @@ void M2(int x, params double[] array) { }
       ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
     IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: 'M2(1)')
       IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: 'M2(1)')
-        Dimension Sizes(1): ILiteralExpression (Text: 0) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: 'M2(1)')
+        Dimension Sizes(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: 'M2(1)')
         Initializer: IArrayInitializer (0 elements) (OperationKind.ArrayInitializer) (Syntax: 'M2(1)')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
@@ -548,7 +548,7 @@ Dimension Sizes(1): ILiteralExpression (Text: 0) (OperationKind.LiteralExpressio
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact]
+        [Fact(Skip = "123")]
         public void DefaultValueAndParamsArrayArgumentInExpandedFormWithNoArgument()
         {
             string source = @"
@@ -599,7 +599,7 @@ void M2(int x = 0, params double[] array) { }
   Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: array) (OperationKind.Argument) (Syntax: 'a')
       ILocalReferenceExpression: a (OperationKind.LocalReferenceExpression, Type: System.Double[]) (Syntax: 'a')
     IArgument (ArgumentKind.DefaultValue, Matching Parameter: x) (OperationKind.Argument) (Syntax: 'M2(array: a)')
-      ILiteralExpression (Text: 0) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: 'M2(array: a)')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: 'M2(array: a)')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
@@ -625,12 +625,12 @@ void M2(int x = 0, params double[] array) { }
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
   Arguments(2): IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: 'M2(array: 1)')
       IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: 'M2(array: 1)')
-        Dimension Sizes(1): ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: 'M2(array: 1)')
+        Dimension Sizes(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: 'M2(array: 1)')
         Initializer: IArrayInitializer (1 elements) (OperationKind.ArrayInitializer) (Syntax: 'M2(array: 1)')
             Element Values(1): IConversionExpression (ConversionKind.CSharp, Implicit) (OperationKind.ConversionExpression, Type: System.Double, Constant: 1) (Syntax: '1')
                 ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
     IArgument (ArgumentKind.DefaultValue, Matching Parameter: x) (OperationKind.Argument) (Syntax: 'M2(array: 1)')
-      ILiteralExpression (Text: 0) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: 'M2(array: 1)')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: 'M2(array: 1)')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
@@ -686,7 +686,7 @@ void M2(int x = 0, params double[] array) { }
       ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
     IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: 'M2(1, array: 1)')
       IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: 'M2(1, array: 1)')
-        Dimension Sizes(1): ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: 'M2(1, array: 1)')
+        Dimension Sizes(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: 'M2(1, array: 1)')
         Initializer: IArrayInitializer (1 elements) (OperationKind.ArrayInitializer) (Syntax: 'M2(1, array: 1)')
             Element Values(1): IConversionExpression (ConversionKind.CSharp, Implicit) (OperationKind.ConversionExpression, Type: System.Double, Constant: 1) (Syntax: '1')
                 ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
@@ -744,7 +744,7 @@ void M2(int x = 0, params double[] array) { }
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
   Arguments(2): IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: 'M2(array: 1, x: 10)')
       IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: 'M2(array: 1, x: 10)')
-        Dimension Sizes(1): ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: 'M2(array: 1, x: 10)')
+        Dimension Sizes(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: 'M2(array: 1, x: 10)')
         Initializer: IArrayInitializer (1 elements) (OperationKind.ArrayInitializer) (Syntax: 'M2(array: 1, x: 10)')
             Element Values(1): IConversionExpression (ConversionKind.CSharp, Implicit) (OperationKind.ConversionExpression, Type: System.Double, Constant: 1) (Syntax: '1')
                 ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
@@ -780,11 +780,11 @@ void M2(
 IInvocationExpression ( void P.M2([System.String memberName = null], [System.String sourceFilePath = null], [System.Int32 sourceLineNumber = 0])) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'M2()')
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
   Arguments(3): IArgument (ArgumentKind.DefaultValue, Matching Parameter: memberName) (OperationKind.Argument) (Syntax: 'M2()')
-      ILiteralExpression (Text: M1) (OperationKind.LiteralExpression, Type: System.String, Constant: ""M1"") (Syntax: 'M2()')
-    IArgument(ArgumentKind.DefaultValue, Matching Parameter: sourceFilePath)(OperationKind.Argument)(Syntax: 'M2()')
-      ILiteralExpression(Text: )(OperationKind.LiteralExpression, Type: System.String, Constant: """")(Syntax: 'M2()')
-    IArgument(ArgumentKind.DefaultValue, Matching Parameter: sourceLineNumber)(OperationKind.Argument)(Syntax: 'M2()')
-      ILiteralExpression(Text: 8)(OperationKind.LiteralExpression, Type: System.Int32, Constant: 8)(Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""M1"") (Syntax: 'M2()')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceFilePath) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""file.cs"") (Syntax: 'M2()')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceLineNumber) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 8) (Syntax: 'M2()')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
@@ -814,11 +814,11 @@ bool M2(
 IInvocationExpression ( System.Boolean P.M2([System.String memberName = null], [System.String sourceFilePath = null], [System.Int32 sourceLineNumber = 0])) (OperationKind.InvocationExpression, Type: System.Boolean) (Syntax: 'M2()')
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
   Arguments(3): IArgument (ArgumentKind.DefaultValue, Matching Parameter: memberName) (OperationKind.Argument) (Syntax: 'M2()')
-      ILiteralExpression (Text: get_M1) (OperationKind.LiteralExpression, Type: System.String, Constant: ""get_M1"") (Syntax: 'M2()')
-    IArgument(ArgumentKind.DefaultValue, Matching Parameter: sourceFilePath)(OperationKind.Argument)(Syntax: 'M2()')
-      ILiteralExpression(Text: )(OperationKind.LiteralExpression, Type: System.String, Constant: """")(Syntax: 'M2()')
-    IArgument(ArgumentKind.DefaultValue, Matching Parameter: sourceLineNumber)(OperationKind.Argument)(Syntax: 'M2()')
-      ILiteralExpression(Text: 6)(OperationKind.LiteralExpression, Type: System.Int32, Constant: 6)(Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""get_M1"") (Syntax: 'M2()')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceFilePath) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""file.cs"") (Syntax: 'M2()')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceLineNumber) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 6) (Syntax: 'M2()')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
@@ -847,12 +847,12 @@ static bool M2(
             string expectedOperationTree = @"
 IInvocationExpression (static System.Boolean P.M2([System.String memberName = null], [System.String sourceFilePath = null], [System.Int32 sourceLineNumber = 0])) (OperationKind.InvocationExpression, Type: System.Boolean) (Syntax: 'M2()')
   Arguments(3): IArgument (ArgumentKind.DefaultValue, Matching Parameter: memberName) (OperationKind.Argument) (Syntax: 'M2()')
-      ILiteralExpression (Text: field) (OperationKind.LiteralExpression, Type: System.String, Constant: ""field"") (Syntax: 'M2()')
-    IArgument(ArgumentKind.DefaultValue, Matching Parameter: sourceFilePath)(OperationKind.Argument)(Syntax: 'M2()')
-      ILiteralExpression(Text: )(OperationKind.LiteralExpression, Type: System.String, Constant: """")(Syntax: 'M2()')
-    IArgument(ArgumentKind.DefaultValue, Matching Parameter: sourceLineNumber)(OperationKind.Argument)(Syntax: 'M2()')
-      ILiteralExpression(Text: 6)(OperationKind.LiteralExpression, Type: System.Int32, Constant: 6)(Syntax: 'M2()')"
-;
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""field"") (Syntax: 'M2()')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceFilePath) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""file.cs"") (Syntax: 'M2()')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceLineNumber) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 6) (Syntax: 'M2()')
+";
             var expectedDiagnostics = DiagnosticDescription.None;
 
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IIfStatement.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IIfStatement.cs
index c355d43e5bbf6..862397adaf8b0 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IIfStatement.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IIfStatement.cs
@@ -436,7 +436,7 @@ private void A(bool flag)
 ";
             string expectedOperationTree = @"
 IIfStatement (OperationKind.IfStatement) (Syntax: 'if (true) ... }')
-  Condition: ILiteralExpression (Text: True) (OperationKind.LiteralExpression, Type: System.Boolean, Constant: True) (Syntax: 'true')
+  Condition: ILiteralExpression (OperationKind.LiteralExpression, Type: System.Boolean, Constant: True) (Syntax: 'true')
   IfTrue: IBlockStatement (1 statements, 1 locals) (OperationKind.BlockStatement) (Syntax: '{ ... }')
       Locals: Local_1: System.Int32 i
       IExpressionStatement (OperationKind.ExpressionStatement) (Syntax: 'A(int.TryPa ... ut var i));')
diff --git a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
index f314880a484b5..c1687d1007dd7 100644
--- a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
@@ -268,7 +268,7 @@ protected void VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(CSharpCompi
         protected void VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(string testSrc, string expectedOperationTree, DiagnosticDescription[] expectedDiagnostics, CSharpCompilationOptions compilationOptions = null, CSharpParseOptions parseOptions = null)
             where TSyntaxNode : SyntaxNode
         {
-            var compilation = CreateCompilationWithMscorlib45(testSrc, options: compilationOptions ?? TestOptions.ReleaseDll, parseOptions: parseOptions);
+            var compilation = CreateCompilationWithMscorlib46(testSrc, new[] { ValueTupleRef, SystemRuntimeFacadeRef }, sourceFileName: "file.cs", options: compilationOptions ?? TestOptions.ReleaseDll, parseOptions: parseOptions);
             VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(compilation, expectedOperationTree, expectedDiagnostics);
         }
     }

From ba40a984d5dccc91bd6836bbb3b730b3cb1137b6 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Sat, 6 May 2017 23:58:46 -0700
Subject: [PATCH 166/284] Fix rebase error

---
 .../CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs   | 2 +-
 .../CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
index 527a609676837..32ca0dde2f65f 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
@@ -642,7 +642,7 @@ private BoundNode IntroduceFrame(BoundNode node, LambdaFrame frame, Func<ArrayBu
 
                 prologue.Add(new BoundAssignmentOperator(syntax,
                     new BoundLocal(syntax, framePointer, null, frameType),
-                    new BoundObjectCreationExpression(syntax: syntax, constructor: constructor),
+                    new BoundObjectCreationExpression(syntax: syntax, constructor: constructor, binderOpt: null),
                     frameType));
             }
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
index 38f2704bf686f..bdb86a3114895 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
@@ -314,7 +314,7 @@ private bool TryGetWellKnownTypeMember<TSymbol>(SyntaxNode syntax, WellKnownMemb
 
         /// <summary>
         /// This function provides a false sense of security, it is likely going to surprise you when the requested member is missing.
-        /// Recommendation: Do not use, use <see cref="TryGetSpecialTypeMethod"/> instead! 
+        /// Recommendation: Do not use, use <see cref="TryGetSpecialTypeMethod(SyntaxNode, SpecialMember, out MethodSymbol)"/> instead! 
         /// If used, a unit-test with a missing member is absolutely a must have.
         /// </summary>
         private MethodSymbol UnsafeGetSpecialTypeMethod(SyntaxNode syntax, SpecialMember specialMember)

From c85afe8b702178cb72c967f0e835a2c4792b2e92 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Sun, 7 May 2017 01:06:14 -0700
Subject: [PATCH 167/284] Move empty param array argument to the end of
 argument list

---
 .../LocalRewriter/LocalRewriter_Call.cs       | 45 +++++++++----------
 .../IOperation/IOperationTests_IArgument.cs   |  8 ++--
 2 files changed, 25 insertions(+), 28 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index 8a5f7472a5010..f22f830f360b5 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -388,7 +388,7 @@ internal ImmutableArray<BoundExpression> MakeArguments(
             //
             // If none of those are the case then we can just take an early out.
 
-            if (TryReturnEarly(ref rewrittenArguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, _factory, out var isComReceiver, out var temporariesBuilder))
+            if (IsRewritingRequired(ref rewrittenArguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, _factory, out var isComReceiver, out var temporariesBuilder))
             {
                 temps = temporariesBuilder?.ToImmutableAndFree() ?? default(ImmutableArray<LocalSymbol>);
                 return rewrittenArguments;
@@ -522,7 +522,7 @@ internal static ImmutableArray<BoundExpression> MakeArgumentsInEvaluationOrder(
 
             ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters();
 
-            if (TryReturnEarly(ref arguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, null, out var isComReceiver, out var temporariesBuilder))
+            if (IsRewritingRequired(ref arguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, null, out var isComReceiver, out var temporariesBuilder))
             {
                 // In this case, the invocation is not in expanded form and there's no named argument provided.
                 // So we just return list of arguments as is.
@@ -547,7 +547,7 @@ internal static ImmutableArray<BoundExpression> MakeArgumentsInEvaluationOrder(
         }
 
         // temporariesBuilder will be null when factory is null.
-        private static bool TryReturnEarly(
+        private static bool IsRewritingRequired(
             ref ImmutableArray<BoundExpression> rewrittenArguments,
             Symbol methodOrIndexer,
             bool expanded,
@@ -731,7 +731,7 @@ private static void BuildExplicitArgumentsInEvaluationOrder(
                     var paramArrayType = parameters[p].Type;
                     var arrayArgs = paramArray.ToImmutableAndFree();
 
-                    argument = CreateParamArrayArgument(syntax, methodOrIndexer, paramArrayType, arrayArgs, compilation, null, false);
+                    argument = CreateParamArrayArgument(syntax, methodOrIndexer.ContainingAssembly, paramArrayType, arrayArgs, compilation, null, false);
                 }
 
                 argumentsBuilder.Add(argument);
@@ -739,19 +739,6 @@ private static void BuildExplicitArgumentsInEvaluationOrder(
                 parametersBuilder.Add(parameter);
             }
 
-            // Create an empty array for omitted param array argument.
-            ParameterSymbol lastParameter;
-            if (expanded && (lastParameter = parameters.Last()).IsParams && !processedPeremeters.Contains(parameters.Length - 1))
-            {
-                var argument = CreateParamArrayArgument(syntax, methodOrIndexer, lastParameter.Type, ImmutableArray<BoundExpression>.Empty, compilation, null, false);
-
-                argumentsBuilder.Add(argument);
-                argumentKindsBuilder.Add(ArgumentKind.ParamArray);
-                parametersBuilder.Add(lastParameter);
-
-                processedPeremeters.Add(parameters.Length - 1);
-            }
-
             // Fill in parameters with missing arguments.
             for (int i = 0; i < parameters.Length; ++i)
             {
@@ -829,13 +816,13 @@ private BoundExpression BuildParamsArray(
                 }
             }
 
-            return CreateParamArrayArgument(syntax, methodOrIndexer, paramArrayType, arrayArgs, _compilation, _factory.CurrentMethod, _inExpressionLambda);
+            return CreateParamArrayArgument(syntax, methodOrIndexer.ContainingAssembly, paramArrayType, arrayArgs, _compilation, _factory.CurrentMethod, _inExpressionLambda);
         }
 
-        private static BoundExpression CreateParamArrayArgument(SyntaxNode syntax, Symbol methodOrIndexer, TypeSymbol paramArrayType, ImmutableArray<BoundExpression> arrayArgs, CSharpCompilation compilation, MethodSymbol currentMethod, bool inExpressionLambda)
+        private static BoundExpression CreateParamArrayArgument(SyntaxNode syntax, AssemblySymbol containingAssembly, TypeSymbol paramArrayType, ImmutableArray<BoundExpression> arrayArgs, CSharpCompilation compilation, MethodSymbol currentMethod, bool inExpressionLambda)
         {
 
-            var int32Type = methodOrIndexer.ContainingAssembly.GetSpecialType(SpecialType.System_Int32);
+            var int32Type = containingAssembly.GetSpecialType(SpecialType.System_Int32);
 
             return new BoundArrayCreation(
                 syntax,
@@ -1001,12 +988,22 @@ private static void AppendMissingOptionalArguments(SyntaxNode syntax,
         {
             foreach (var parameter in missingParameters)
             {
-                Debug.Assert(parameter.IsOptional);
+                if (parameter.IsParams)
+                {
+                    // Create an empty array for omitted param array argument.
+                    var paramArray = CreateParamArrayArgument(syntax, parameter.ContainingAssembly, parameter.Type, ImmutableArray<BoundExpression>.Empty, binder.Compilation, null, false);
 
-                var defaultArgument = GetDefaultParameterValue(syntax, parameter, enableCallerInfo, null, binder.Compilation, binder.ContainingMember(), new DiagnosticBag());
+                    argumentsBuilder.Add(paramArray);
+                    argumentKindsBuilder.Add(ArgumentKind.ParamArray);
+                }
+                else
+                {
+                    Debug.Assert(parameter.IsOptional);
+                    var defaultArgument = GetDefaultParameterValue(syntax, parameter, enableCallerInfo, null, binder.Compilation, binder.ContainingMember(), new DiagnosticBag());
 
-                argumentsBuilder.Add(defaultArgument);
-                argumentKindsBuilder.Add(ArgumentKind.DefaultValue);
+                    argumentsBuilder.Add(defaultArgument);
+                    argumentKindsBuilder.Add(ArgumentKind.DefaultValue);  
+                }
                 parametersBuilder.Add(parameter);
             }
         }
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index bda935a0f1033..e5834edc17f79 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -548,7 +548,7 @@ Dimension Sizes(1): ILiteralExpression (OperationKind.LiteralExpression, Type: S
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "123")]
+        [Fact]
         public void DefaultValueAndParamsArrayArgumentInExpandedFormWithNoArgument()
         {
             string source = @"
@@ -567,11 +567,11 @@ void M2(int x = 0, params double[] array) { }
 IInvocationExpression ( void P.M2([System.Int32 x = 0], params System.Double[] array)) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'M2()')
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
   Arguments(2): IArgument (ArgumentKind.DefaultValue, Matching Parameter: x) (OperationKind.Argument) (Syntax: 'M2()')
-      ILiteralExpression (Text: 0) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: 'M2()')
     IArgument (ArgumentKind.ParamArray, Matching Parameter: array) (OperationKind.Argument) (Syntax: 'M2()')
       IArrayCreationExpression (Element Type: System.Double) (OperationKind.ArrayCreationExpression, Type: System.Double[]) (Syntax: 'M2()')
-        Dimension Sizes(1): ILiteralExpression (Text: 0) (OperationKind.LiteralExpression, Type: null, Constant: 0) (Syntax: 'M2()')
-        Initializer: IArrayInitializer (OperationKind.ArrayInitializer) (Syntax: 'M2()')
+        Dimension Sizes(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: 'M2()')
+        Initializer: IArrayInitializer (0 elements) (OperationKind.ArrayInitializer) (Syntax: 'M2()')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 

From f474bb241631e48622d0e97aafc4ba36095a7f0e Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Sun, 7 May 2017 11:41:27 -0700
Subject: [PATCH 168/284] Fix operation test references

---
 .../Test/Semantic/IOperation/IOperationTests_IArgument.cs  | 6 +++---
 .../Test/Utilities/CSharp/SemanticModelTestBase.cs         | 7 +++++--
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index e5834edc17f79..fe857bdbd92ef 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -788,7 +788,7 @@ void M2(
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics, additionalReferences: new[] { MscorlibRef_v46 });
         }
 
         [Fact]
@@ -822,7 +822,7 @@ bool M2(
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics, additionalReferences: new[] { MscorlibRef_v46 });
         }
 
         [Fact]
@@ -855,7 +855,7 @@ static bool M2(
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics, additionalReferences: new[] { MscorlibRef_v46 });
         }
 
         [Fact]
diff --git a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
index c1687d1007dd7..b3397356ab550 100644
--- a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
@@ -265,10 +265,13 @@ protected void VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(CSharpCompi
             VerifyOperationTreeForTest<TSyntaxNode>(compilation, expectedOperationTree);
         }
 
-        protected void VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(string testSrc, string expectedOperationTree, DiagnosticDescription[] expectedDiagnostics, CSharpCompilationOptions compilationOptions = null, CSharpParseOptions parseOptions = null)
+        private static readonly MetadataReference[] s_defaultOperationReferences = new[] { SystemRef, SystemCoreRef, ValueTupleRef, SystemRuntimeFacadeRef };
+
+        protected void VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(string testSrc, string expectedOperationTree, DiagnosticDescription[] expectedDiagnostics, CSharpCompilationOptions compilationOptions = null, CSharpParseOptions parseOptions = null, MetadataReference[] additionalReferences = null)
             where TSyntaxNode : SyntaxNode
         {
-            var compilation = CreateCompilationWithMscorlib46(testSrc, new[] { ValueTupleRef, SystemRuntimeFacadeRef }, sourceFileName: "file.cs", options: compilationOptions ?? TestOptions.ReleaseDll, parseOptions: parseOptions);
+            var references = additionalReferences == null ? s_defaultOperationReferences : additionalReferences.Concat(s_defaultOperationReferences);
+            var compilation = CreateStandardCompilation(testSrc, references, sourceFileName: "file.cs", options: compilationOptions ?? TestOptions.ReleaseDll, parseOptions: parseOptions);
             VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(compilation, expectedOperationTree, expectedDiagnostics);
         }
     }

From e855d4b55e760c07e85fe680d6d9320093f95692 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Sun, 7 May 2017 13:10:09 -0700
Subject: [PATCH 169/284] Fix value of CallerMemberName argument

---
 .../LocalRewriter/LocalRewriter_Call.cs       | 46 ++++++++++++++----
 .../LocalRewriter/LocalRewriter_Literal.cs    |  6 +++
 .../IOperation/IOperationTests_IArgument.cs   | 47 ++++++++++++++++++-
 3 files changed, 90 insertions(+), 9 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index f22f830f360b5..bc20b0945b0a2 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -978,6 +978,8 @@ private void InsertMissingOptionalArguments(SyntaxNode syntax,
             }
         }
 
+        private static readonly DiagnosticBag s_notUsedDiagnosticBagForDerivingArgumentsForIOperation = new DiagnosticBag();
+
         private static void AppendMissingOptionalArguments(SyntaxNode syntax,
             ImmutableArray<ParameterSymbol> missingParameters,
             Binder binder,
@@ -999,13 +1001,14 @@ private static void AppendMissingOptionalArguments(SyntaxNode syntax,
                 else
                 {
                     Debug.Assert(parameter.IsOptional);
-                    var defaultArgument = GetDefaultParameterValue(syntax, parameter, enableCallerInfo, null, binder.Compilation, binder.ContainingMember(), new DiagnosticBag());
+                    var defaultArgument = GetDefaultParameterValue(syntax, parameter, enableCallerInfo, null, binder, s_notUsedDiagnosticBagForDerivingArgumentsForIOperation);
 
                     argumentsBuilder.Add(defaultArgument);
                     argumentKindsBuilder.Add(ArgumentKind.DefaultValue);  
                 }
                 parametersBuilder.Add(parameter);
             }
+            s_notUsedDiagnosticBagForDerivingArgumentsForIOperation.Clear();
         }
 
         private static SourceLocation GetCallerLocation(SyntaxNode syntax, ThreeState enableCallerInfo)
@@ -1069,23 +1072,29 @@ private static SourceLocation GetCallerLocation(SyntaxNode syntax, ThreeState en
         /// </remarks>  
         private BoundExpression GetDefaultParameterValue(SyntaxNode syntax, ParameterSymbol parameter, ThreeState enableCallerInfo)
         {
-            return GetDefaultParameterValue(syntax, parameter, enableCallerInfo, this, null, null, null);
+            return GetDefaultParameterValue(syntax, parameter, enableCallerInfo, this, null, null);
         }
 
+        /// <summary>
+        /// This helper is used by both LocalRewriter and IOperation. 
+        ///   - For lowering, 'localRewriter' must be passed in as an argument, and set 'binder' and 'diagnostics' to null.
+        ///   - For deriving argument expression for IArgument operation, 'localRewriter' must be null, and 'compilation', 'diagnostics' 
+        ///     must be passed in, where 'callerMemberName' must not be null if 'parameter.IsCallerMemberName' is 'true'.
+        /// </summary>
         private static BoundExpression GetDefaultParameterValue(
             SyntaxNode syntax, 
             ParameterSymbol parameter,
             ThreeState enableCallerInfo,
             LocalRewriter localRewriter,
-            CSharpCompilation compilation,
-            Symbol containingMemberSymbol, 
+            Binder binder,
             DiagnosticBag diagnostics)
         {
-            Debug.Assert(localRewriter == null ^ (compilation == null && containingMemberSymbol == null && diagnostics == null));
+            Debug.Assert(localRewriter == null ^ (binder == null && diagnostics == null));
 
-            bool isLowering = false;
+            bool isLowering;
             bool inExpressionLambda = false;
             MethodSymbol currentMethod = null;
+            CSharpCompilation compilation; 
 
             if (localRewriter != null)
             {
@@ -1095,6 +1104,11 @@ private static BoundExpression GetDefaultParameterValue(
                 currentMethod = localRewriter._factory.CurrentMethod;
                 diagnostics = localRewriter._diagnostics;
             }
+            else
+            {
+                isLowering = false; 
+                compilation = binder.Compilation; 
+            }
 
             // TODO: Ideally, the enableCallerInfo parameter would be of just bool type with only 'true' and 'false' values, and all callers
             // explicitly provided one of those values, so that we do not rely on shape of syntax nodes in the rewriter. There are not many immediate callers, 
@@ -1208,8 +1222,24 @@ private static BoundExpression GetDefaultParameterValue(
                     }
                 }
                 else
-                {
-                    memberName = containingMemberSymbol.Name;
+                { 
+                    // If the parameter has 'CallerMemberNameAttribute' applied to it, and the containg member is
+                    // property getter/setter or event add/remove, we need to retrieve the actual property and event name instead.
+                    var containingMember = binder.ContainingMember();
+                    if (containingMember.Kind == SymbolKind.Method)
+                    {
+                        var containingMethod = (MethodSymbol)containingMember;
+                        switch (containingMethod.MethodKind)
+                        {
+                            case MethodKind.PropertyGet:
+                            case MethodKind.PropertySet:
+                            case MethodKind.EventAdd:
+                            case MethodKind.EventRemove:
+                                containingMember = containingMethod.AssociatedSymbol;
+                                break;
+                        }
+                    }
+                    memberName = containingMember.Name; 
                 }
 
                 BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(memberName), compilation.GetSpecialType(SpecialType.System_String), compilation, currentMethod, inExpressionLambda);  
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs
index 640db515274aa..124ca17012660 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs
@@ -21,6 +21,9 @@ private BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue constantVal
             return MakeLiteral(syntax, constantValue, type, _compilation, _factory.CurrentMethod, _inExpressionLambda, oldNodeOpt);
         }
 
+        /// <summary>
+        /// Pass in 'currentMethod' and 'inExpressionLambda' if this is called during lowering, otherwise set 'currentMethod' to null (i.e. for IOperation purposes) 
+        /// </summary>
         private static BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue constantValue, TypeSymbol type, CSharpCompilation compilation, MethodSymbol currentMethod, bool inExpressionLambda)
         {
             return MakeLiteral(syntax, constantValue, type, compilation, currentMethod, inExpressionLambda, null);
@@ -57,6 +60,9 @@ private static BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue cons
             }
         }
 
+        /// <summary>
+        /// If 'currentMethod' is null, we will skip optimization of calling a simpler constructor, or using a predefined constant
+        /// </summary>
         private static BoundExpression MakeDecimalLiteral(SyntaxNode syntax, ConstantValue constantValue, CSharpCompilation compilation, MethodSymbol currentMethod, bool inExpressionLambda)
         {
             Debug.Assert(constantValue != null);
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index fe857bdbd92ef..72fa238092c15 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -814,7 +814,7 @@ bool M2(
 IInvocationExpression ( System.Boolean P.M2([System.String memberName = null], [System.String sourceFilePath = null], [System.Int32 sourceLineNumber = 0])) (OperationKind.InvocationExpression, Type: System.Boolean) (Syntax: 'M2()')
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
   Arguments(3): IArgument (ArgumentKind.DefaultValue, Matching Parameter: memberName) (OperationKind.Argument) (Syntax: 'M2()')
-      ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""get_M1"") (Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""M1"") (Syntax: 'M2()')
     IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceFilePath) (OperationKind.Argument) (Syntax: 'M2()')
       ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""file.cs"") (Syntax: 'M2()')
     IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceLineNumber) (OperationKind.Argument) (Syntax: 'M2()')
@@ -858,6 +858,51 @@ static bool M2(
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics, additionalReferences: new[] { MscorlibRef_v46 });
         }
 
+        [Fact]
+        public void CallerInfoAttributesInvokedInEventMethods()
+        {
+            string source = @"
+using System;
+using System.Runtime.CompilerServices;
+
+class P
+{
+    public event EventHandler MyEvent
+    {
+        add
+        {
+            /*<bind>*/M2()/*</bind>*/;
+        }
+
+        remove
+        {
+            M2();
+        }
+    }
+
+    static bool M2(
+        [CallerMemberName] string memberName = null,
+        [CallerFilePath] string sourceFilePath = null,
+        [CallerLineNumber] int sourceLineNumber = 0)
+    {
+        return true;
+    }
+}
+";
+            string expectedOperationTree = @"
+IInvocationExpression (static System.Boolean P.M2([System.String memberName = null], [System.String sourceFilePath = null], [System.Int32 sourceLineNumber = 0])) (OperationKind.InvocationExpression, Type: System.Boolean) (Syntax: 'M2()')
+  Arguments(3): IArgument (ArgumentKind.DefaultValue, Matching Parameter: memberName) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""MyEvent"") (Syntax: 'M2()')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceFilePath) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""file.cs"") (Syntax: 'M2()')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: sourceLineNumber) (OperationKind.Argument) (Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 11) (Syntax: 'M2()')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics, additionalReferences: new[] { MscorlibRef_v46 });
+        }
+
         [Fact]
         public void ExtraArgument()
         {

From 614f45f537bab4aa03800d1cdcca57e398abedf6 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Sun, 7 May 2017 13:37:51 -0700
Subject: [PATCH 170/284] Short circuit the logic when invocation has no
 arguments

---
 .../CSharp/Portable/BoundTree/Expression.cs   |  8 +++++++
 .../IOperation/IOperationTests_IArgument.cs   | 22 +++++++++++++++++++
 2 files changed, 30 insertions(+)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index 322f4a54b94b2..42d9345265fe1 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -91,6 +91,14 @@ internal static ImmutableArray<IArgument> DeriveArguments(
             SyntaxNode invocationSyntax,
             bool invokedAsExtensionMethod = false)
         {
+            // We can simply return empty array only if both parameters and boundArguments are empty, because:
+            // - if only parameters is empty, there's error in code but we still need to return provided expression.
+            // - if boundArguments is empty, then either there's error or we need to provide values for optional/param-array parameters. 
+            if (parameters.IsDefaultOrEmpty && boundArguments.IsDefaultOrEmpty)
+            {
+                return ImmutableArray<IArgument>.Empty;
+            }
+
             return (ImmutableArray<IArgument>) s_callToArgumentsMappings.GetValue(
                 boundNode, 
                 (n) =>
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index 72fa238092c15..d1651c6bdf894 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -8,6 +8,28 @@ namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
     public partial class IOperationTests : SemanticModelTestBase
     {
+        [Fact]
+        public void NoArgument()
+        {
+            string source = @"
+class P
+{
+    static void M1()
+    {
+        /*<bind>*/M2()/*</bind>*/;
+    }
+
+    static void M2() { }
+}
+";
+            string expectedOperationTree = @"
+IInvocationExpression (static void P.M2()) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'M2()')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
         [Fact]
         public void PositionalArgument()
         {

From ec7bfaadf23774942212a0c10bd36becb2c408a4 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Fri, 12 May 2017 17:18:40 -0700
Subject: [PATCH 171/284] Refactor code around MakeArgumentsInEvaluationOrder
 based on review comments

---
 .../CSharp/Portable/BoundTree/BoundNodes.xml  |   6 +
 .../CSharp/Portable/BoundTree/Expression.cs   |  88 ++-----
 .../Lowering/LocalRewriter/LocalRewriter.cs   |   9 +-
 .../LocalRewriter_BinaryOperator.cs           |   5 +
 .../LocalRewriter/LocalRewriter_Call.cs       | 225 +++++++++---------
 .../LocalRewriter/LocalRewriter_Conversion.cs |  15 +-
 .../LocalRewriter/LocalRewriter_Literal.cs    |  63 ++---
 .../IOperation/IOperationTests_IArgument.cs   | 144 +++++++++++
 8 files changed, 326 insertions(+), 229 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index b7c5e74d05a2e..cec1c250b9f4f 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -1201,6 +1201,8 @@
     <Field Name="InvokedAsExtensionMethod" Type="bool"/>
     <Field Name="ArgsToParamsOpt" Type="ImmutableArray&lt;int&gt;" Null="allow"/>
     <Field Name="ResultKind" PropertyOverrides="true" Type="LookupResultKind"/>
+    
+    <!-- BinderOpt is added as a temporary solution for IOperation implementation and should probably be removed in the future -->
     <Field Name="BinderOpt" Type="Binder" Null="allow"/>
   </Node>
 
@@ -1247,6 +1249,8 @@
     <Field Name="ArgsToParamsOpt" Type="ImmutableArray&lt;int&gt;" Null="allow"/>
     <Field Name="ConstantValueOpt" Type="ConstantValue" Null="allow"/>
     <Field Name="InitializerExpressionOpt" Type="BoundExpression" Null="allow"/>
+
+    <!-- BinderOpt is added as a temporary solution for IOperation implementation and should probably be removed in the future -->
     <Field Name="BinderOpt" Type="Binder" Null="allow"/>
   </Node>
   
@@ -1493,6 +1497,8 @@
     <Field Name="ArgumentRefKindsOpt" Type="ImmutableArray&lt;RefKind&gt;" Null="allow"/>
     <Field Name="Expanded" Type="bool"/>
     <Field Name="ArgsToParamsOpt" Type="ImmutableArray&lt;int&gt;" Null="allow"/>
+
+    <!-- BinderOpt is added as a temporary solution for IOperation implementation and should probably be removed in the future -->
     <Field Name="BinderOpt" Type="Binder" Null="allow"/>
   </Node>
 
diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index 42d9345265fe1..a2d0fd86ce692 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -75,7 +75,20 @@ public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, T
         }
 
         private static readonly ConditionalWeakTable<BoundExpression, IEnumerable<IArgument>> s_callToArgumentsMappings 
-            = new ConditionalWeakTable<BoundExpression, IEnumerable<IArgument>>();
+            = new ConditionalWeakTable<BoundExpression, IEnumerable<IArgument>>(); 
+
+        internal static IArgument CreateArgumentOperation(ArgumentKind kind, IParameterSymbol parameter, IOperation value)
+        {
+            return new Argument(kind,
+                parameter,
+                value,
+                inConversion: null,
+                outConversion: null,
+                isInvalid: parameter == null || value.IsInvalid,
+                syntax: value.Syntax,
+                type: value.Type,
+                constantValue: default(Optional<object>));
+        }
 
         internal static ImmutableArray<IArgument> DeriveArguments(
             BoundExpression boundNode,
@@ -90,7 +103,7 @@ internal static ImmutableArray<IArgument> DeriveArguments(
             bool expanded,
             SyntaxNode invocationSyntax,
             bool invokedAsExtensionMethod = false)
-        {
+        {                       
             // We can simply return empty array only if both parameters and boundArguments are empty, because:
             // - if only parameters is empty, there's error in code but we still need to return provided expression.
             // - if boundArguments is empty, then either there's error or we need to provide values for optional/param-array parameters. 
@@ -104,8 +117,8 @@ internal static ImmutableArray<IArgument> DeriveArguments(
                 (n) =>
                 {
                     //TODO: https://github.com/dotnet/roslyn/issues/18722
-                    //      Right now, for errornous code, we try to recover as much data as we can
-                    //      and expose them as IArguments, so user needs to check IsInvalid firdt before using 
+                    //      Right now, for erroneous code, we try to recover as much data as we can
+                    //      and expose them as IArguments, so user needs to check IsInvalid first before using 
                     //      anything we returned. Need to implement a new interface for invalid invocation instead.
                     if (n.HasErrors)
                     {
@@ -120,16 +133,13 @@ internal static ImmutableArray<IArgument> DeriveArguments(
                                                 ? parameters[argumentsToParametersOpt[a]]
                                                 : null);
 
-                            argumentsWithErrors.Add(new Argument(ArgumentKind.Explicit, parameter, boundArguments[a]));
+                            argumentsWithErrors.Add(CreateArgumentOperation(ArgumentKind.Explicit, parameter, boundArguments[a]));
                         }
 
                         return argumentsWithErrors.ToImmutableAndFree();
-                    } 
-
-                    var argumentKindBuilder = ArrayBuilder<ArgumentKind>.GetInstance(parameters.Length);
-                    var parameterSymbolBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameters.Length);
+                    }                                                                                           
 
-                    var derivedArguments = LocalRewriter.MakeArgumentsInEvaluationOrder(
+                   return LocalRewriter.MakeArgumentsInEvaluationOrder(
                         binder: binder,
                         syntax: invocationSyntax,
                         arguments: boundArguments,
@@ -137,65 +147,9 @@ internal static ImmutableArray<IArgument> DeriveArguments(
                         optionalParametersMethod: optionalParametersMethod,
                         expanded: expanded,
                         argsToParamsOpt: argumentsToParametersOpt,
-                        invokedAsExtensionMethod: invokedAsExtensionMethod,
-                        argumentKindBuilder: argumentKindBuilder,
-                        parameterSymbolBuilder: parameterSymbolBuilder);
-                    
-                    Debug.Assert(derivedArguments.Length == parameters.Length 
-                              && derivedArguments.Length == argumentKindBuilder.Count
-                              && derivedArguments.Length == parameterSymbolBuilder.Count);
-                    
-                    ArrayBuilder<IArgument> argumentsInEvaluationBuilder = ArrayBuilder<IArgument>.GetInstance(parameters.Length);
-                    for (int a = 0; a < derivedArguments.Length; a++)
-                    {
-                        argumentsInEvaluationBuilder.Add(new Argument(argumentKindBuilder[a], parameterSymbolBuilder[a], derivedArguments[a]));
-                    }
-
-                    return argumentsInEvaluationBuilder.ToImmutableAndFree();
+                        invokedAsExtensionMethod: invokedAsExtensionMethod); 
                 });
         }
-
-        private class Argument : IArgument
-        {
-            public Argument(ArgumentKind kind, IParameterSymbol parameter, IOperation value)
-            {
-                Debug.Assert(value != null);
-
-                this.Value = value;
-                this.Parameter = parameter;
-                this.ArgumentKind = kind;
-            }
-
-            public IParameterSymbol Parameter { get; }
-
-            public IOperation Value { get; }
-
-            IOperation IArgument.InConversion => null;
-
-            IOperation IArgument.OutConversion => null;
-
-            bool IOperation.IsInvalid => (object)this.Parameter == null || this.Value.IsInvalid;
-
-            OperationKind IOperation.Kind => OperationKind.Argument;
-
-            SyntaxNode IOperation.Syntax => this.Value?.Syntax;
-
-            public ITypeSymbol Type => null;
-
-            public Optional<object> ConstantValue => default(Optional<object>);
-
-            public ArgumentKind ArgumentKind { get; }
-
-            void IOperation.Accept(OperationVisitor visitor)
-            {
-                visitor.VisitArgument(this);
-            }
-
-            TResult IOperation.Accept<TArgument, TResult>(OperationVisitor<TArgument, TResult> visitor, TArgument argument)
-            {
-                return visitor.VisitArgument(this, argument);
-            }
-        }
     }
 
     internal partial class BoundLocal : ILocalReferenceExpression
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
index bdb86a3114895..5082200ad4345 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
@@ -31,7 +31,7 @@ internal sealed partial class LocalRewriter : BoundTreeRewriterWithStackGuard
 
         private Dictionary<BoundValuePlaceholderBase, BoundExpression> _placeholderReplacementMapDoNotUseDirectly;
 
-        internal LocalRewriter(
+        private LocalRewriter(
             CSharpCompilation compilation,
             MethodSymbol containingMethod,
             int containingMethodOrdinal,
@@ -46,7 +46,7 @@ internal LocalRewriter(
             _compilation = compilation;
             _factory = factory;
             _factory.CurrentMethod = containingMethod;
-            Debug.Assert(factory.CurrentType == (containingType ?? containingMethod?.ContainingType));
+            Debug.Assert(factory.CurrentType == (containingType ?? containingMethod.ContainingType));
             _dynamicFactory = new LoweredDynamicOperationFactory(factory, containingMethodOrdinal);
             _previousSubmissionFields = previousSubmissionFields;
             _allowOmissionOfConditionalCalls = allowOmissionOfConditionalCalls;
@@ -322,6 +322,11 @@ private MethodSymbol UnsafeGetSpecialTypeMethod(SyntaxNode syntax, SpecialMember
             return UnsafeGetSpecialTypeMethod(syntax, specialMember, _compilation, _diagnostics);
         }
 
+        /// <summary>
+        /// This function provides a false sense of security, it is likely going to surprise you when the requested member is missing.
+        /// Recommendation: Do not use, use <see cref="TryGetSpecialTypeMethod(SyntaxNode, SpecialMember, CSharpCompilation, DiagnosticBag, out MethodSymbol)"/> instead! 
+        /// If used, a unit-test with a missing member is absolutely a must have.
+        /// </summary>
         private static MethodSymbol UnsafeGetSpecialTypeMethod(SyntaxNode syntax, SpecialMember specialMember, CSharpCompilation compilation, DiagnosticBag diagnostics)
         {
             MethodSymbol method;
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs
index f6f40b7dc7a64..8ec81d79de3d8 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs
@@ -1725,6 +1725,11 @@ private MethodSymbol UnsafeGetNullableMethod(SyntaxNode syntax, TypeSymbol nulla
             return UnsafeGetNullableMethod(syntax, nullableType, member, _compilation, _diagnostics);
         }
 
+        /// <summary>
+        /// This function provides a false sense of security, it is likely going to surprise you when the requested member is missing.
+        /// Recommendation: Do not use, use <see cref="TryGetNullableMethod"/> instead! 
+        /// If used, a unit-test with a missing member is absolutely a must have.
+        /// </summary>
         private static MethodSymbol UnsafeGetNullableMethod(SyntaxNode syntax, TypeSymbol nullableType, SpecialMember member, CSharpCompilation compilation, DiagnosticBag diagnostics)
         {
             var nullableType2 = nullableType as NamedTypeSymbol;
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index bc20b0945b0a2..5fca6a91f3414 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -361,7 +361,7 @@ private static bool IsSafeForReordering(BoundExpression expression, RefKind kind
         /// itself. <paramref name="optionalParametersMethod"/> is needed for indexers since getter and setter
         /// may have distinct optional parameter values.
         /// </summary>
-        internal ImmutableArray<BoundExpression> MakeArguments(
+        private ImmutableArray<BoundExpression> MakeArguments(
             SyntaxNode syntax,
             ImmutableArray<BoundExpression> rewrittenArguments,
             Symbol methodOrIndexer,
@@ -388,7 +388,7 @@ internal ImmutableArray<BoundExpression> MakeArguments(
             //
             // If none of those are the case then we can just take an early out.
 
-            if (IsRewritingRequired(ref rewrittenArguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, _factory, out var isComReceiver, out var temporariesBuilder))
+            if (CanSkipRewriting(ref rewrittenArguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, _factory, out var isComReceiver, out var temporariesBuilder))
             {
                 temps = temporariesBuilder?.ToImmutableAndFree() ?? default(ImmutableArray<LocalSymbol>);
                 return rewrittenArguments;
@@ -490,7 +490,7 @@ internal ImmutableArray<BoundExpression> MakeArguments(
             return actualArguments.AsImmutableOrNull();
         }
 
-        internal static ImmutableArray<BoundExpression> MakeArgumentsInEvaluationOrder(
+        internal static ImmutableArray<IArgument> MakeArgumentsInEvaluationOrder(
             Binder binder,
             SyntaxNode syntax,
             ImmutableArray<BoundExpression> arguments,
@@ -498,56 +498,60 @@ internal static ImmutableArray<BoundExpression> MakeArgumentsInEvaluationOrder(
             MethodSymbol optionalParametersMethod,
             bool expanded,
             ImmutableArray<int> argsToParamsOpt,
-            bool invokedAsExtensionMethod,
-            /* out */ ArrayBuilder<ArgumentKind> argumentKindBuilder,
-            /* out */ ArrayBuilder<ParameterSymbol> parameterSymbolBuilder,
-            ThreeState enableCallerInfo = ThreeState.Unknown)
+            bool invokedAsExtensionMethod)
         {
-            Debug.Assert(binder != null && argumentKindBuilder.IsEmpty() && parameterSymbolBuilder.IsEmpty());
+            Debug.Assert(binder != null);
 
             // Either the methodOrIndexer is a property, in which case the method used
             // for optional parameters is an accessor of that property (or an overridden
             // property), or the methodOrIndexer is used for optional parameters directly.
             Debug.Assert(((methodOrIndexer.Kind == SymbolKind.Property) && optionalParametersMethod.IsAccessor()) ||
-                ReferenceEquals(methodOrIndexer, optionalParametersMethod));
+                (object)methodOrIndexer == optionalParametersMethod);
 
             // We need to do a fancy rewrite under the following circumstances:
-            // (1) a params array is being used; we need to generate the array.
-            // (2) there were named arguments that reordered the arguments; we might
-            //     have to generate temporaries to ensure that the arguments are 
-            //     evaluated in source code order, not the actual call order.
-            // (3) there were optional parameters that had no corresponding arguments.
+            // (1) a params array is being used; we need to generate the array. 
+            // (2) there were optional parameters that had no corresponding arguments.
             //
-            // If none of those are the case then we can just take an early out.
+            // If neither of those are the case then we can just take an early out.
 
-            ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters();
+            ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters(); 
 
-            if (IsRewritingRequired(ref arguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, null, out var isComReceiver, out var temporariesBuilder))
-            {
-                // In this case, the invocation is not in expanded form and there's no named argument provided.
-                // So we just return list of arguments as is.
-                for(int i = 0; i < arguments.Length; ++i)
-                {
-                    argumentKindBuilder.Add(ArgumentKind.Explicit);
-                    parameterSymbolBuilder.Add(parameters[i]);
-                }
-                return arguments;
-            }
+            ArrayBuilder<IArgument> argumentsInEvaluationBuilder = ArrayBuilder<IArgument>.GetInstance(parameters.Length);
 
+            bool canSkipRewriting = CanSkipRewriting(ref arguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, null, out var isComReceiver, out var temporariesBuilder);
             Debug.Assert(temporariesBuilder == null);
 
-            ArrayBuilder<BoundExpression> argumentsBuilder = ArrayBuilder<BoundExpression>.GetInstance(parameters.Length);
+            if (canSkipRewriting)
+            {
+                Debug.Assert(temporariesBuilder == null);
+
+                // In this case, the invocation is not in expanded form and there's no named argument provided.
+                // So we just return list of arguments as is.   
+                for (int i = 0; i < arguments.Length; i++)
+                {                                                 
+                    argumentsInEvaluationBuilder.Add(BoundCall.CreateArgumentOperation(ArgumentKind.Explicit, parameters[i], arguments[i]));
+                } 
+                return argumentsInEvaluationBuilder.ToImmutableAndFree(); ;
+            }                                                                                                                   
+
             ArrayBuilder<ParameterSymbol> missingParametersBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameters.Length);
 
-            BuildExplicitArgumentsInEvaluationOrder(syntax, methodOrIndexer, expanded, argsToParamsOpt, arguments, binder.Compilation, argumentsBuilder, argumentKindBuilder, parameterSymbolBuilder, missingParametersBuilder);
+            BuildExplicitArgumentsInEvaluationOrder(syntax, 
+                methodOrIndexer, 
+                expanded, 
+                argsToParamsOpt, 
+                arguments, 
+                binder, 
+                argumentsInEvaluationBuilder, 
+                missingParametersBuilder);
 
-            AppendMissingOptionalArguments(syntax, missingParametersBuilder.ToImmutableAndFree(), binder, argumentsBuilder, argumentKindBuilder, parameterSymbolBuilder);
+            AppendMissingOptionalArguments(syntax, methodOrIndexer, expanded, binder, missingParametersBuilder.ToImmutableAndFree(), argumentsInEvaluationBuilder);
 
-            return argumentsBuilder.ToImmutableAndFree();
+            return argumentsInEvaluationBuilder.ToImmutableAndFree();
         }
 
         // temporariesBuilder will be null when factory is null.
-        private static bool IsRewritingRequired(
+        private static bool CanSkipRewriting(
             ref ImmutableArray<BoundExpression> rewrittenArguments,
             Symbol methodOrIndexer,
             bool expanded,
@@ -685,14 +689,12 @@ private static void BuildExplicitArgumentsInEvaluationOrder(
             bool expanded,
             ImmutableArray<int> argsToParamsOpt,
             ImmutableArray<BoundExpression> arguments,
-            CSharpCompilation compilation,
-            /* out */ ArrayBuilder<BoundExpression> argumentsBuilder,
-            /* out */ ArrayBuilder<ArgumentKind> argumentKindsBuilder,
-            /* out */ ArrayBuilder<ParameterSymbol> parametersBuilder,
+            Binder binder,
+            /* out */ ArrayBuilder<IArgument> argumentsBuilder,
             /* out */ ArrayBuilder<ParameterSymbol> missingParametersBuilder)
         {
             ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters();
-            PooledHashSet<int> processedPeremeters = PooledHashSet<int>.GetInstance();
+            ArrayBuilder<int> processedParameters = ArrayBuilder<int>.GetInstance(parameters.Length);
 
             for (int a = 0; a < arguments.Length; ++a)
             {
@@ -701,8 +703,9 @@ private static void BuildExplicitArgumentsInEvaluationOrder(
                 int p = (!argsToParamsOpt.IsDefault) ? argsToParamsOpt[a] : a;
                 var parameter = parameters[p];
 
-                bool processed = processedPeremeters.Add(p);
-                Debug.Assert(processed);
+                Debug.Assert(!processedParameters.Contains(p));
+
+                processedParameters.Add(p); 
 
                 bool isParamArray = false;
                 if (expanded && p == parameters.Length - 1)
@@ -731,23 +734,21 @@ private static void BuildExplicitArgumentsInEvaluationOrder(
                     var paramArrayType = parameters[p].Type;
                     var arrayArgs = paramArray.ToImmutableAndFree();
 
-                    argument = CreateParamArrayArgument(syntax, methodOrIndexer.ContainingAssembly, paramArrayType, arrayArgs, compilation, null, false);
+                    argument = CreateParamArrayArgument(syntax, paramArrayType, arrayArgs, null, binder);
                 }
 
-                argumentsBuilder.Add(argument);
-                argumentKindsBuilder.Add(isParamArray ? ArgumentKind.ParamArray : ArgumentKind.Explicit);
-                parametersBuilder.Add(parameter);
+                argumentsBuilder.Add(BoundCall.CreateArgumentOperation(isParamArray ? ArgumentKind.ParamArray : ArgumentKind.Explicit, parameter, argument)); 
             }
 
             // Fill in parameters with missing arguments.
             for (int i = 0; i < parameters.Length; ++i)
             {
-                if (!processedPeremeters.Contains(i))
+                if (!processedParameters.Contains(i))
                 {
                     missingParametersBuilder.Add(parameters[i]);
                 }
             }
-            processedPeremeters.Free();
+            processedParameters.Free();
         }
 
         private BoundExpression BuildParamsArray(
@@ -816,22 +817,42 @@ private BoundExpression BuildParamsArray(
                 }
             }
 
-            return CreateParamArrayArgument(syntax, methodOrIndexer.ContainingAssembly, paramArrayType, arrayArgs, _compilation, _factory.CurrentMethod, _inExpressionLambda);
+            return CreateParamArrayArgument(syntax, paramArrayType, arrayArgs, this, null);
         }
 
-        private static BoundExpression CreateParamArrayArgument(SyntaxNode syntax, AssemblySymbol containingAssembly, TypeSymbol paramArrayType, ImmutableArray<BoundExpression> arrayArgs, CSharpCompilation compilation, MethodSymbol currentMethod, bool inExpressionLambda)
+        private static BoundExpression CreateParamArrayArgument(SyntaxNode syntax,
+            TypeSymbol paramArrayType, 
+            ImmutableArray<BoundExpression> arrayArgs, 
+            LocalRewriter localRewriter,
+            Binder binder)
         {
-
-            var int32Type = containingAssembly.GetSpecialType(SpecialType.System_Int32);
+            Debug.Assert(localRewriter == null ^ binder == null);  
+                                                                            
+            TypeSymbol int32Type = (localRewriter != null ? localRewriter._compilation : binder.Compilation).GetSpecialType(SpecialType.System_Int32);
+            BoundExpression arraySize = MakeLiteral(syntax, ConstantValue.Create(arrayArgs.Length), int32Type, localRewriter);    
 
             return new BoundArrayCreation(
                 syntax,
-                ImmutableArray.Create(
-                    MakeLiteral(syntax, ConstantValue.Create(arrayArgs.Length), int32Type, compilation, currentMethod, inExpressionLambda)),
+                ImmutableArray.Create(arraySize),
                 new BoundArrayInitialization(syntax, arrayArgs),
                 paramArrayType);
         }
 
+        /// <summary>
+        /// To create literal expression for IOperation, set localRewriter to null.
+        /// </summary>
+        private static BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue constantValue, TypeSymbol type, LocalRewriter localRewriter)
+        {
+            if (localRewriter != null)
+            {
+                return localRewriter.MakeLiteral(syntax, constantValue, type);
+            }
+            else
+            {
+                return new BoundLiteral(syntax, constantValue, type);
+            }
+        }
+
         private static void OptimizeTemporaries(
             BoundExpression[] arguments,
             ArrayBuilder<RefKind> refKinds,
@@ -978,37 +999,36 @@ private void InsertMissingOptionalArguments(SyntaxNode syntax,
             }
         }
 
-        private static readonly DiagnosticBag s_notUsedDiagnosticBagForDerivingArgumentsForIOperation = new DiagnosticBag();
-
         private static void AppendMissingOptionalArguments(SyntaxNode syntax,
-            ImmutableArray<ParameterSymbol> missingParameters,
+            Symbol methodOrIndexer,
+            bool expanded, 
             Binder binder,
-            ArrayBuilder<BoundExpression> argumentsBuilder,
-            ArrayBuilder<ArgumentKind> argumentKindsBuilder,
-            ArrayBuilder<ParameterSymbol> parametersBuilder,
-            ThreeState enableCallerInfo = ThreeState.Unknown)
+            ImmutableArray<ParameterSymbol> missingParameters,
+            ArrayBuilder<IArgument> argumentsBuilder)
         {
+            ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters();
             foreach (var parameter in missingParameters)
             {
-                if (parameter.IsParams)
+                if (expanded && parameter.Ordinal == parameters.Length - 1)
                 {
+                    Debug.Assert(parameter.IsParams);
+
                     // Create an empty array for omitted param array argument.
-                    var paramArray = CreateParamArrayArgument(syntax, parameter.ContainingAssembly, parameter.Type, ImmutableArray<BoundExpression>.Empty, binder.Compilation, null, false);
+                    var paramArray = CreateParamArrayArgument(syntax, parameter.Type, ImmutableArray<BoundExpression>.Empty, null, binder);
 
-                    argumentsBuilder.Add(paramArray);
-                    argumentKindsBuilder.Add(ArgumentKind.ParamArray);
+                    argumentsBuilder.Add(BoundCall.CreateArgumentOperation(ArgumentKind.ParamArray, parameter, paramArray)); 
                 }
                 else
                 {
                     Debug.Assert(parameter.IsOptional);
-                    var defaultArgument = GetDefaultParameterValue(syntax, parameter, enableCallerInfo, null, binder, s_notUsedDiagnosticBagForDerivingArgumentsForIOperation);
 
-                    argumentsBuilder.Add(defaultArgument);
-                    argumentKindsBuilder.Add(ArgumentKind.DefaultValue);  
-                }
-                parametersBuilder.Add(parameter);
-            }
-            s_notUsedDiagnosticBagForDerivingArgumentsForIOperation.Clear();
+                    var unusedDiagnostics = DiagnosticBag.GetInstance();
+                    var defaultArgument = GetDefaultParameterValue(syntax, parameter, enableCallerInfo: ThreeState.Unknown, localRewriter: null, binder: binder, diagnostics: unusedDiagnostics);
+                    unusedDiagnostics.Free();
+
+                    argumentsBuilder.Add(BoundCall.CreateArgumentOperation(ArgumentKind.DefaultValue, parameter, defaultArgument));
+                }                               
+            }                                                               
         }
 
         private static SourceLocation GetCallerLocation(SyntaxNode syntax, ThreeState enableCallerInfo)
@@ -1072,7 +1092,7 @@ private static SourceLocation GetCallerLocation(SyntaxNode syntax, ThreeState en
         /// </remarks>  
         private BoundExpression GetDefaultParameterValue(SyntaxNode syntax, ParameterSymbol parameter, ThreeState enableCallerInfo)
         {
-            return GetDefaultParameterValue(syntax, parameter, enableCallerInfo, this, null, null);
+            return GetDefaultParameterValue(syntax, parameter, enableCallerInfo, this, null, this._diagnostics);
         }
 
         /// <summary>
@@ -1089,20 +1109,16 @@ private static BoundExpression GetDefaultParameterValue(
             Binder binder,
             DiagnosticBag diagnostics)
         {
-            Debug.Assert(localRewriter == null ^ (binder == null && diagnostics == null));
+            Debug.Assert(localRewriter == null ^ binder == null);
+            Debug.Assert(diagnostics != null);
 
-            bool isLowering;
-            bool inExpressionLambda = false;
-            MethodSymbol currentMethod = null;
+            bool isLowering;                  
             CSharpCompilation compilation; 
 
             if (localRewriter != null)
             {
                 isLowering = true;
                 compilation = localRewriter._compilation;
-                inExpressionLambda = localRewriter._inExpressionLambda;
-                currentMethod = localRewriter._factory.CurrentMethod;
-                diagnostics = localRewriter._diagnostics;
             }
             else
             {
@@ -1122,8 +1138,9 @@ private static BoundExpression GetDefaultParameterValue(
             SourceLocation callerSourceLocation;
 
             // For compatibility with the native compiler we treat all bad imported constant
-            // values as default(T).  
-            if (defaultConstantValue != null && defaultConstantValue.IsBad)
+            // values as default(T). However, we don't do this for IOperation purpose, in which case
+            // we will expose the bad node.
+            if (defaultConstantValue != null && defaultConstantValue.IsBad && isLowering)
             {
                 defaultConstantValue = ConstantValue.Null;
             }
@@ -1132,14 +1149,14 @@ private static BoundExpression GetDefaultParameterValue(
             {
                 int line = callerSourceLocation.SourceTree.GetDisplayLineNumber(callerSourceLocation.SourceSpan);
                                      
-                BoundExpression lineLiteral = MakeLiteral(syntax, ConstantValue.Create(line), compilation.GetSpecialType(SpecialType.System_Int32), compilation, currentMethod, inExpressionLambda);
+                BoundExpression lineLiteral = MakeLiteral(syntax, ConstantValue.Create(line), compilation.GetSpecialType(SpecialType.System_Int32), localRewriter);
 
                 if (parameterType.IsNullableType())
                 {
                     TypeSymbol nullableType = parameterType.GetNullableUnderlyingType();
                     defaultValue = isLowering
                         ? localRewriter.MakeConversionNode(lineLiteral, nullableType, false)                
-                        : MakeConversionNodeIfNecessaryWithoutLowering(lineLiteral, nullableType, syntax, compilation, diagnostics, false); 
+                        : MakeConversionForIOperation(lineLiteral, nullableType, syntax, compilation, diagnostics, false); 
 
                     // wrap it in a nullable ctor.
                     defaultValue = new BoundObjectCreationExpression(
@@ -1152,16 +1169,16 @@ private static BoundExpression GetDefaultParameterValue(
                 {                                                                                                                                     
                     defaultValue = isLowering
                         ? localRewriter.MakeConversionNode(lineLiteral, parameterType, false)
-                        : MakeConversionNodeIfNecessaryWithoutLowering(lineLiteral, parameterType, syntax, compilation, diagnostics, false);
+                        : MakeConversionForIOperation(lineLiteral, parameterType, syntax, compilation, diagnostics, false);
                 }  
             }
             else if (parameter.IsCallerFilePath && ((callerSourceLocation = GetCallerLocation(syntax, enableCallerInfo)) != null))
             {
                 string path = callerSourceLocation.SourceTree.GetDisplayPath(callerSourceLocation.SourceSpan, compilation.Options.SourceReferenceResolver);
-                BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(path), compilation.GetSpecialType(SpecialType.System_String), compilation, currentMethod, inExpressionLambda); 
+                BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(path), compilation.GetSpecialType(SpecialType.System_String), localRewriter); 
                 defaultValue = isLowering
                     ? localRewriter.MakeConversionNode(memberNameLiteral, parameterType, false)
-                    : MakeConversionNodeIfNecessaryWithoutLowering(memberNameLiteral, parameterType, syntax, compilation, diagnostics, false);
+                    : MakeConversionForIOperation(memberNameLiteral, parameterType, syntax, compilation, diagnostics, false);
             }
             else if (parameter.IsCallerMemberName && ((callerSourceLocation = GetCallerLocation(syntax, enableCallerInfo)) != null))
             {
@@ -1222,30 +1239,14 @@ private static BoundExpression GetDefaultParameterValue(
                     }
                 }
                 else
-                { 
-                    // If the parameter has 'CallerMemberNameAttribute' applied to it, and the containg member is
-                    // property getter/setter or event add/remove, we need to retrieve the actual property and event name instead.
-                    var containingMember = binder.ContainingMember();
-                    if (containingMember.Kind == SymbolKind.Method)
-                    {
-                        var containingMethod = (MethodSymbol)containingMember;
-                        switch (containingMethod.MethodKind)
-                        {
-                            case MethodKind.PropertyGet:
-                            case MethodKind.PropertySet:
-                            case MethodKind.EventAdd:
-                            case MethodKind.EventRemove:
-                                containingMember = containingMethod.AssociatedSymbol;
-                                break;
-                        }
-                    }
-                    memberName = containingMember.Name; 
+                {  
+                    memberName = binder.ContainingMember().GetMemberCallerName(); 
                 }
 
-                BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(memberName), compilation.GetSpecialType(SpecialType.System_String), compilation, currentMethod, inExpressionLambda);  
+                BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(memberName), compilation.GetSpecialType(SpecialType.System_String), localRewriter);  
                 defaultValue = isLowering
                     ? localRewriter.MakeConversionNode(memberNameLiteral, parameterType, false)
-                    : MakeConversionNodeIfNecessaryWithoutLowering(memberNameLiteral, parameterType, syntax, compilation, diagnostics, false);
+                    : MakeConversionForIOperation(memberNameLiteral, parameterType, syntax, compilation, diagnostics, false);
             }
             else if (defaultConstantValue == ConstantValue.NotAvailable)
             {                                                                                 
@@ -1255,7 +1256,7 @@ private static BoundExpression GetDefaultParameterValue(
                     // We have something like M([Optional] object x). We have special handling for such situations.
                     defaultValue = isLowering 
                         ? localRewriter.GetDefaultParameterSpecial(syntax, parameter)
-                        : GetDefaultParameterSpecialWithOutLowering(syntax, parameter, compilation, diagnostics);
+                        : GetDefaultParameterSpecialForIOperation(syntax, parameter, compilation, diagnostics);
                 }
                 else
                 {
@@ -1275,14 +1276,14 @@ private static BoundExpression GetDefaultParameterValue(
                 // with new double?(1.23).
 
                 TypeSymbol constantType = compilation.GetSpecialType(defaultConstantValue.SpecialType);
-                defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType, compilation, currentMethod, inExpressionLambda);
+                defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType, localRewriter);
 
                 // The parameter's underlying type might not match the constant type. For example, we might have
                 // a default value of 5 (an integer) but a parameter type of decimal?.
 
                 defaultValue = isLowering
                     ? localRewriter.MakeConversionNode(defaultValue, parameterType.GetNullableUnderlyingType(), @checked: false, acceptFailingConversion: true)
-                    : MakeConversionNodeIfNecessaryWithoutLowering(defaultValue, parameterType.GetNullableUnderlyingType(), syntax, compilation, diagnostics, @checked: false, acceptFailingConversion: true);
+                    : MakeConversionForIOperation(defaultValue, parameterType.GetNullableUnderlyingType(), syntax, compilation, diagnostics, @checked: false, acceptFailingConversion: true);
 
                 // Finally, wrap it in a nullable ctor.
                 defaultValue = new BoundObjectCreationExpression(
@@ -1293,18 +1294,18 @@ private static BoundExpression GetDefaultParameterValue(
             }
             else if (defaultConstantValue.IsNull || defaultConstantValue.IsBad)
             {
-                defaultValue = MakeLiteral(syntax, defaultConstantValue, parameterType, compilation, currentMethod, inExpressionLambda);
+                defaultValue = MakeLiteral(syntax, defaultConstantValue, parameterType, localRewriter);
             }
             else
             {
                 // We have something like M(double x = 1.23), so replace the argument with 1.23.
 
                 TypeSymbol constantType = compilation.GetSpecialType(defaultConstantValue.SpecialType);
-                defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType, compilation, currentMethod, inExpressionLambda);
+                defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType, localRewriter);
                 // The parameter type might not match the constant type.                                                                                                                    
                 defaultValue = isLowering
                     ? localRewriter.MakeConversionNode(defaultValue, parameterType, @checked: false, acceptFailingConversion: true)
-                    : MakeConversionNodeIfNecessaryWithoutLowering(defaultValue, parameterType, syntax, compilation, diagnostics, @checked: false, acceptFailingConversion: true);
+                    : MakeConversionForIOperation(defaultValue, parameterType, syntax, compilation, diagnostics, @checked: false, acceptFailingConversion: true);
             }
 
             return defaultValue;
@@ -1316,10 +1317,10 @@ private BoundExpression GetDefaultParameterSpecial(SyntaxNode syntax, ParameterS
             return MakeConversionNode(defaultValue, parameter.Type, @checked: false);
         }
 
-        private static BoundExpression GetDefaultParameterSpecialWithOutLowering(SyntaxNode syntax, ParameterSymbol parameter, CSharpCompilation compilation, DiagnosticBag diagnostics)
+        private static BoundExpression GetDefaultParameterSpecialForIOperation(SyntaxNode syntax, ParameterSymbol parameter, CSharpCompilation compilation, DiagnosticBag diagnostics)
         {
             BoundExpression defaultValue = GetDefaultParameterSpecialNoConversion(syntax, parameter, compilation);
-            return MakeConversionNodeIfNecessaryWithoutLowering(defaultValue, parameter.Type, syntax, compilation, diagnostics, @checked: false);
+            return MakeConversionForIOperation(defaultValue, parameter.Type, syntax, compilation, diagnostics, @checked: false);
         }
 
         private static BoundExpression GetDefaultParameterSpecialNoConversion(SyntaxNode syntax, ParameterSymbol parameter, CSharpCompilation compilation)
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
index a2395b76fb21f..3e76aadb3133c 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
@@ -495,7 +495,7 @@ private static Conversion MakeConversion(
             return conversion;
         } 
 
-        private static BoundExpression MakeConversionNodeIfNecessaryWithoutLowering(
+        private static BoundExpression MakeConversionForIOperation(
             BoundExpression operand, 
             TypeSymbol type, 
             SyntaxNode syntax, 
@@ -504,15 +504,11 @@ private static BoundExpression MakeConversionNodeIfNecessaryWithoutLowering(
             bool @checked, 
             bool acceptFailingConversion = false)
         {
-            if (operand.Type.Equals(type))
-            {
-                return operand;
-            }
-            Conversion conversion = MakeConversion(operand, type, compilation, diagnostics, acceptFailingConversion); 
+            Conversion conversion = MakeConversion(operand, type, compilation, diagnostics, acceptFailingConversion);
 
-            if (!conversion.IsValid)
+            if (conversion.Kind == ConversionKind.Identity)
             {
-                return SyntheticBoundNodeFactory.NullOrDefault(type, syntax);
+                return operand;
             }
 
             return new BoundConversion(
@@ -522,7 +518,8 @@ private static BoundExpression MakeConversionNodeIfNecessaryWithoutLowering(
                             @checked: @checked,
                             explicitCastInCode: false,
                             constantValueOpt: default(ConstantValue),
-                            type: type);
+                            type: type,
+                            hasErrors: !conversion.IsValid);
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs
index 124ca17012660..d8ba8ef9e36a3 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Literal.cs
@@ -17,19 +17,6 @@ public override BoundNode VisitLiteral(BoundLiteral node)
         }
 
         private BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue constantValue, TypeSymbol type, BoundLiteral oldNodeOpt = null)
-        {
-            return MakeLiteral(syntax, constantValue, type, _compilation, _factory.CurrentMethod, _inExpressionLambda, oldNodeOpt);
-        }
-
-        /// <summary>
-        /// Pass in 'currentMethod' and 'inExpressionLambda' if this is called during lowering, otherwise set 'currentMethod' to null (i.e. for IOperation purposes) 
-        /// </summary>
-        private static BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue constantValue, TypeSymbol type, CSharpCompilation compilation, MethodSymbol currentMethod, bool inExpressionLambda)
-        {
-            return MakeLiteral(syntax, constantValue, type, compilation, currentMethod, inExpressionLambda, null);
-        }
-
-        private static BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue constantValue, TypeSymbol type, CSharpCompilation compilation, MethodSymbol currentMethod, bool inExpressionLambda, BoundLiteral oldNodeOpt)
         {
             Debug.Assert(constantValue != null);
 
@@ -39,7 +26,7 @@ private static BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue cons
                 Debug.Assert((object)type != null);
                 Debug.Assert(type.SpecialType == SpecialType.System_Decimal);
 
-                return MakeDecimalLiteral(syntax, constantValue, compilation, currentMethod, inExpressionLambda);
+                return MakeDecimalLiteral(syntax, constantValue);
             }
             else if (constantValue.IsDateTime)
             {
@@ -48,7 +35,7 @@ private static BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue cons
                 // for its default value.
                 Debug.Assert((object)type != null);
                 Debug.Assert(type.SpecialType == SpecialType.System_DateTime);
-                return MakeDateTimeLiteral(syntax, constantValue, compilation);
+                return MakeDateTimeLiteral(syntax, constantValue);
             }
             else if (oldNodeOpt != null)
             {
@@ -60,10 +47,7 @@ private static BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue cons
             }
         }
 
-        /// <summary>
-        /// If 'currentMethod' is null, we will skip optimization of calling a simpler constructor, or using a predefined constant
-        /// </summary>
-        private static BoundExpression MakeDecimalLiteral(SyntaxNode syntax, ConstantValue constantValue, CSharpCompilation compilation, MethodSymbol currentMethod, bool inExpressionLambda)
+        private BoundExpression MakeDecimalLiteral(SyntaxNode syntax, ConstantValue constantValue)
         {
             Debug.Assert(constantValue != null);
             Debug.Assert(constantValue.IsDecimal);
@@ -78,27 +62,28 @@ private static BoundExpression MakeDecimalLiteral(SyntaxNode syntax, ConstantVal
             SpecialMember member;
 
             // check if we can call a simpler constructor, or use a predefined constant
-            if (scale == 0 && int.MinValue <= value && value <= int.MaxValue && currentMethod != null)
+            if (scale == 0 && int.MinValue <= value && value <= int.MaxValue)
             {
                 // If we are building static constructor of System.Decimal, accessing static fields 
                 // would be bad.
-                if ((currentMethod.MethodKind != MethodKind.SharedConstructor ||
-                   currentMethod.ContainingType.SpecialType != SpecialType.System_Decimal) &&
-                   !inExpressionLambda)
+                var curMethod = _factory.CurrentMethod;
+                if ((curMethod.MethodKind != MethodKind.SharedConstructor ||
+                   curMethod.ContainingType.SpecialType != SpecialType.System_Decimal) &&
+                   !_inExpressionLambda)
                 {
                     Symbol useField = null;
 
                     if (value == decimal.Zero)
                     {
-                        useField = compilation.GetSpecialTypeMember(SpecialMember.System_Decimal__Zero);
+                        useField = _compilation.GetSpecialTypeMember(SpecialMember.System_Decimal__Zero);
                     }
                     else if (value == decimal.One)
                     {
-                        useField = compilation.GetSpecialTypeMember(SpecialMember.System_Decimal__One);
+                        useField = _compilation.GetSpecialTypeMember(SpecialMember.System_Decimal__One);
                     }
                     else if (value == decimal.MinusOne)
                     {
-                        useField = compilation.GetSpecialTypeMember(SpecialMember.System_Decimal__MinusOne);
+                        useField = _compilation.GetSpecialTypeMember(SpecialMember.System_Decimal__MinusOne);
                     }
 
                     if ((object)useField != null &&
@@ -112,38 +97,38 @@ private static BoundExpression MakeDecimalLiteral(SyntaxNode syntax, ConstantVal
 
                 //new decimal(int);
                 member = SpecialMember.System_Decimal__CtorInt32;
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((int)value), compilation.GetSpecialType(SpecialType.System_Int32)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((int)value), _compilation.GetSpecialType(SpecialType.System_Int32)));
             }
             else if (scale == 0 && uint.MinValue <= value && value <= uint.MaxValue)
             {
                 //new decimal(uint);
                 member = SpecialMember.System_Decimal__CtorUInt32;
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((uint)value), compilation.GetSpecialType(SpecialType.System_UInt32)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((uint)value), _compilation.GetSpecialType(SpecialType.System_UInt32)));
             }
             else if (scale == 0 && long.MinValue <= value && value <= long.MaxValue)
             {
                 //new decimal(long);
                 member = SpecialMember.System_Decimal__CtorInt64;
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((long)value), compilation.GetSpecialType(SpecialType.System_Int64)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((long)value), _compilation.GetSpecialType(SpecialType.System_Int64)));
             }
             else if (scale == 0 && ulong.MinValue <= value && value <= ulong.MaxValue)
             {
                 //new decimal(ulong);
                 member = SpecialMember.System_Decimal__CtorUInt64;
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((ulong)value), compilation.GetSpecialType(SpecialType.System_UInt64)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create((ulong)value), _compilation.GetSpecialType(SpecialType.System_UInt64)));
             }
             else
             {
                 //new decimal(int low, int mid, int high, bool isNegative, byte scale);
                 member = SpecialMember.System_Decimal__CtorInt32Int32Int32BooleanByte;
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(low), compilation.GetSpecialType(SpecialType.System_Int32)));
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(mid), compilation.GetSpecialType(SpecialType.System_Int32)));
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(high), compilation.GetSpecialType(SpecialType.System_Int32)));
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(isNegative), compilation.GetSpecialType(SpecialType.System_Boolean)));
-                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(scale), compilation.GetSpecialType(SpecialType.System_Byte)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(low), _compilation.GetSpecialType(SpecialType.System_Int32)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(mid), _compilation.GetSpecialType(SpecialType.System_Int32)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(high), _compilation.GetSpecialType(SpecialType.System_Int32)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(isNegative), _compilation.GetSpecialType(SpecialType.System_Boolean)));
+                arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(scale), _compilation.GetSpecialType(SpecialType.System_Byte)));
             }
 
-            var ctor = (MethodSymbol)compilation.Assembly.GetSpecialTypeMember(member);
+            var ctor = (MethodSymbol)_compilation.Assembly.GetSpecialTypeMember(member);
             Debug.Assert((object)ctor != null);
             Debug.Assert(ctor.ContainingType.SpecialType == SpecialType.System_Decimal);
 
@@ -153,15 +138,15 @@ private static BoundExpression MakeDecimalLiteral(SyntaxNode syntax, ConstantVal
                 constantValue, null, null, ctor.ContainingType);
         }
 
-        private static BoundExpression MakeDateTimeLiteral(SyntaxNode syntax, ConstantValue constantValue, CSharpCompilation compilation)
+        private BoundExpression MakeDateTimeLiteral(SyntaxNode syntax, ConstantValue constantValue)
         {
             Debug.Assert(constantValue != null);
             Debug.Assert(constantValue.IsDateTime);
 
             var arguments = new ArrayBuilder<BoundExpression>();
-            arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(constantValue.DateTimeValue.Ticks), compilation.GetSpecialType(SpecialType.System_Int64)));
+            arguments.Add(new BoundLiteral(syntax, ConstantValue.Create(constantValue.DateTimeValue.Ticks), _compilation.GetSpecialType(SpecialType.System_Int64)));
 
-            var ctor = (MethodSymbol)compilation.Assembly.GetSpecialTypeMember(SpecialMember.System_DateTime__CtorInt64);
+            var ctor = (MethodSymbol)_compilation.Assembly.GetSpecialTypeMember(SpecialMember.System_DateTime__CtorInt64);
             Debug.Assert((object)ctor != null);
             Debug.Assert(ctor.ContainingType.SpecialType == SpecialType.System_DateTime);
 
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index d1651c6bdf894..9df3611618f4e 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -956,5 +956,149 @@ void M2(int x = 0)
 
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
+
+        [Fact]
+        public void WrongArgumentType()
+        {
+            string source = @"
+class P
+{
+    void M1()
+    {
+        /*<bind>*/M2(1)/*</bind>*/;
+    }
+
+    void M2(string x )
+    { }
+}
+";
+            string expectedOperationTree = @"
+IInvocationExpression ( void P.M2(System.String x)) (OperationKind.InvocationExpression, Type: System.Void, IsInvalid) (Syntax: 'M2(1)')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
+  Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '1')
+      ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
+";
+            var expectedDiagnostics = new DiagnosticDescription[] 
+            {
+                // file.cs(6,22): error CS1503: Argument 1: cannot convert from 'int' to 'string'
+                //         /*<bind>*/M2(1)/*</bind>*/;
+                Diagnostic(ErrorCode.ERR_BadArgType, "1").WithArguments("1", "int", "string").WithLocation(6, 22)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [Fact(Skip ="todo")]
+        public void InvalidConversionForDefaultArgument()
+        {
+            string source = @"
+class P
+{
+    void M1()
+    {
+        /*<bind>*/M2()/*</bind>*/;
+    }
+
+    void M2(int x = ""string"")
+    { }
+}
+";
+            string expectedOperationTree = @"
+IInvocationExpression ( void P.M2([System.Int32 x = default(System.Int32)])) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'M2()')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
+  Arguments(1): IArgument (ArgumentKind.DefaultValue, Matching Parameter: x) (OperationKind.Argument, IsInvalid) (Syntax: 'M2()')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: null, IsInvalid) (Syntax: 'M2()')
+";
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // CS1750: A value of type 'string' cannot be used as a default parameter because there are no standard conversions to type 'int'
+                //     void M2(int x = "string")
+                Diagnostic(ErrorCode.ERR_NoConversionForDefaultParam, "x").WithArguments("string", "int")
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [Fact(Skip = "todo")]
+        public void AssigningToIndexerSetter()
+        {
+            string source = @"
+class P
+{
+    private int _number = 0;
+    public int this[int index]
+    {
+        get { return _number; }
+        set { _number = value; }
+    }
+
+    void M1()
+    {
+        /*<bind>*/this[10]/*</bind>*/ = 9;
+    }
+}
+";
+            string expectedOperationTree = @"
+IIndexedPropertyReferenceExpression: System.Int32 P.this[System.Int32 index] { get; set; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32) (Syntax: 'this[10]')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Explicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'this')
+  Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: index) (OperationKind.Argument) (Syntax: '10')
+      ILiteralExpression (Text: 10) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 10) (Syntax: '10')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [Fact(Skip = "todo")]
+        public void AssigningToWriteOnlyIndexer()
+        {
+            string source = @"
+class P
+{
+    private int _number = 0;
+    public int this[int index]
+    {
+        set { _number = value; }
+    }
+
+    void M1()
+    {
+        /*<bind>*/this[10]/*</bind>*/ = 9;
+    }
+}
+";
+            string expectedOperationTree = @"
+IIndexedPropertyReferenceExpression: System.Int32 P.this[System.Int32 index] { set; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32) (Syntax: 'this[10]')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Explicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'this')
+  Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: index) (OperationKind.Argument) (Syntax: '10')
+      ILiteralExpression (Text: 10) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 10) (Syntax: '10')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [Fact(Skip = "todo")]
+        public void AssigningToReadOnlyIndexer()
+        {
+            string source = @"
+class P
+{
+    private int _number = 0;
+    public int this[int index]
+    {
+        get { return _number; }
+    }
+
+    void M1()
+    {
+        /*<bind>*/this[10]/*</bind>*/ = 9;
+    }
+}
+";
+            string expectedOperationTree = @"";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
     }
 }
\ No newline at end of file

From 9f7540f94f622687d9d48b4f773193d888aa45d8 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Fri, 12 May 2017 17:46:06 -0700
Subject: [PATCH 172/284] Fix crash caused by a combination of discard with
 arglist

https://github.com/dotnet/roslyn/issues/19382
---
 .../LocalRewriter/LocalRewriter_Call.cs       | 29 ++++-----------
 .../Test/Semantic/Semantics/OutVarTests.cs    | 37 +++++++++++++++++++
 2 files changed, 45 insertions(+), 21 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index 5fca6a91f3414..3638ddcc4bf56 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -388,14 +388,15 @@ private ImmutableArray<BoundExpression> MakeArguments(
             //
             // If none of those are the case then we can just take an early out.
 
-            if (CanSkipRewriting(ref rewrittenArguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, _factory, out var isComReceiver, out var temporariesBuilder))
+            ArrayBuilder<LocalSymbol> temporariesBuilder = ArrayBuilder<LocalSymbol>.GetInstance();
+            rewrittenArguments = _factory.MakeTempsForDiscardArguments(rewrittenArguments, temporariesBuilder);
+
+            if (CanSkipRewriting(ref rewrittenArguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, out var isComReceiver))
             {
-                temps = temporariesBuilder?.ToImmutableAndFree() ?? default(ImmutableArray<LocalSymbol>);
+                temps = temporariesBuilder.ToImmutableAndFree();
                 return rewrittenArguments;
             }
 
-            Debug.Assert(temporariesBuilder != null);
-
             // We have:
             // * a list of arguments, already converted to their proper types, 
             //   in source code order. Some optional arguments might be missing.
@@ -518,13 +519,10 @@ internal static ImmutableArray<IArgument> MakeArgumentsInEvaluationOrder(
 
             ArrayBuilder<IArgument> argumentsInEvaluationBuilder = ArrayBuilder<IArgument>.GetInstance(parameters.Length);
 
-            bool canSkipRewriting = CanSkipRewriting(ref arguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, null, out var isComReceiver, out var temporariesBuilder);
-            Debug.Assert(temporariesBuilder == null);
+            bool canSkipRewriting = CanSkipRewriting(ref arguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, out var isComReceiver); 
 
             if (canSkipRewriting)
             {
-                Debug.Assert(temporariesBuilder == null);
-
                 // In this case, the invocation is not in expanded form and there's no named argument provided.
                 // So we just return list of arguments as is.   
                 for (int i = 0; i < arguments.Length; i++)
@@ -557,12 +555,8 @@ private static bool CanSkipRewriting(
             bool expanded,
             ImmutableArray<int> argsToParamsOpt,
             bool invokedAsExtensionMethod,
-            SyntheticBoundNodeFactory factory,
-            out bool isComReceiver,
-            out ArrayBuilder<LocalSymbol> temporariesBuilder)
+            out bool isComReceiver)
         {
-            temporariesBuilder = null;
-
             // An applicable "vararg" method could not possibly be applicable in its expanded
             // form, and cannot possibly have named arguments or used optional parameters, 
             // because the __arglist() argument has to be positional and in the last position. 
@@ -573,7 +567,6 @@ private static bool CanSkipRewriting(
                 Debug.Assert(argsToParamsOpt.IsDefault);
                 Debug.Assert(!expanded);
                 isComReceiver = false;
-                temporariesBuilder = null;
                 return true;
             }
 
@@ -581,13 +574,7 @@ private static bool CanSkipRewriting(
                                     ((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol :
                                     methodOrIndexer.ContainingType;
 
-            isComReceiver = (object)receiverNamedType != null && receiverNamedType.IsComImport;
-
-            if (factory != null)
-            {
-                temporariesBuilder = ArrayBuilder<LocalSymbol>.GetInstance();
-                rewrittenArguments = factory.MakeTempsForDiscardArguments(rewrittenArguments, temporariesBuilder);
-            }
+            isComReceiver = (object)receiverNamedType != null && receiverNamedType.IsComImport; 
 
             return rewrittenArguments.Length == methodOrIndexer.GetParameterCount() &&
                 argsToParamsOpt.IsDefault &&
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/OutVarTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/OutVarTests.cs
index 516846814c3f8..7822d00dbf1e7 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/OutVarTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/OutVarTests.cs
@@ -32912,6 +32912,43 @@ IEnumerable<object> M2(out int j)
             Assert.Equal("System.Collections.Generic.IEnumerator<System.Object> System.Collections.Generic.IEnumerable<System.Object>.GetEnumerator()",
                 info.GetEnumeratorMethod.ToTestDisplayString());
         }
+
+        [Fact]
+        [WorkItem(19382, "https://github.com/dotnet/roslyn/issues/19382")]
+        public void DiscardAndArgList()
+        {
+            var text = @"
+using System;
+public class C
+{
+    static void Main()
+    {
+        M(out _, __arglist(2, 3, true));
+    }
+    
+    static void M(out int x, __arglist)
+    {    
+        x = 0;
+        DumpArgs(new ArgIterator(__arglist));
+    }
+
+    static void DumpArgs(ArgIterator args)
+    {
+        while(args.GetRemainingCount() > 0)
+        {
+            TypedReference tr = args.GetNextArg();
+            object arg = TypedReference.ToObject(tr);
+            Console.Write(arg);
+        }
+    }
+}";
+            var compilation = CreateStandardCompilation(text, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular);
+
+            compilation.VerifyDiagnostics(
+                );
+
+            CompileAndVerify(compilation, expectedOutput: "23True");
+        }
     }
 
     internal static class OutVarTestsExtensions

From fa72dd62f539352f2136ad303d03ea8ceb852247 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Fri, 12 May 2017 22:15:49 -0700
Subject: [PATCH 173/284] Make `Patrameter` of all IArguments of invalid
 invocation to be null

---
 .../CSharp/Portable/BoundTree/Expression.cs    | 18 ++++--------------
 .../Semantic/IOperation/IOperationTests.cs     |  4 ++--
 .../IOperation/IOperationTests_IArgument.cs    |  4 ++--
 .../IOperationTests_InvalidExpression.cs       |  2 +-
 4 files changed, 9 insertions(+), 19 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index a2d0fd86ce692..225a1de8a2905 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -117,25 +117,15 @@ internal static ImmutableArray<IArgument> DeriveArguments(
                 (n) =>
                 {
                     //TODO: https://github.com/dotnet/roslyn/issues/18722
-                    //      Right now, for erroneous code, we try to recover as much data as we can
-                    //      and expose them as IArguments, so user needs to check IsInvalid first before using 
-                    //      anything we returned. Need to implement a new interface for invalid invocation instead.
+                    //      Right now, for erroneous code, we exposes all expression in place of arguments as IArgument with Parameter set to null,
+                    //      so user needs to check IsInvalid first before using anything we returned. Need to implement a new interface for invalid invocation instead.
                     if (n.HasErrors)
                     {
                         ArrayBuilder<IArgument> argumentsWithErrors = ArrayBuilder<IArgument>.GetInstance(boundArguments.Length);
-                        for (int a = 0; a < boundArguments.Length; a++)
+                        for (int a = 0; a < boundArguments.Length; ++a)
                         {
-                            var parameter = argumentsToParametersOpt.IsDefault
-                                            ? (a < parameters.Length
-                                                ? parameters[a]
-                                                : null)
-                                            : (argumentsToParametersOpt[a] > 0
-                                                ? parameters[argumentsToParametersOpt[a]]
-                                                : null);
-
-                            argumentsWithErrors.Add(CreateArgumentOperation(ArgumentKind.Explicit, parameter, boundArguments[a]));
+                            argumentsWithErrors.Add(CreateArgumentOperation(ArgumentKind.Explicit, null, boundArguments[a]));
                         }
-
                         return argumentsWithErrors.ToImmutableAndFree();
                     }                                                                                           
 
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests.cs
index 2b393d2991242..f6230c8a364a6 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests.cs
@@ -51,9 +51,9 @@ static void Test2(int y, params int[] x)
 
             compilation.VerifyOperationTree(nodes[1], expectedOperationTree:
 @"IInvocationExpression (static void Cls.Test2(System.Int32 y, params System.Int32[] x)) (OperationKind.InvocationExpression, Type: System.Void, IsInvalid) (Syntax: 'Test2(new o ... ct(), null)')
-  Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: y) (OperationKind.Argument) (Syntax: 'new object()')
+  Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: null) (OperationKind.Argument, IsInvalid) (Syntax: 'new object()')
       IObjectCreationExpression (Constructor: System.Object..ctor()) (OperationKind.ObjectCreationExpression, Type: System.Object) (Syntax: 'new object()')
-    IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: 'null')
+    IArgument (ArgumentKind.Explicit, Matching Parameter: null) (OperationKind.Argument, IsInvalid) (Syntax: 'null')
       ILiteralExpression (Text: null) (OperationKind.LiteralExpression, Type: null, Constant: null) (Syntax: 'null')");
         }
 
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index 9df3611618f4e..068945739376c 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -943,7 +943,7 @@ void M2(int x = 0)
             string expectedOperationTree = @"
 IInvocationExpression ( void P.M2([System.Int32 x = 0])) (OperationKind.InvocationExpression, Type: System.Void, IsInvalid) (Syntax: 'M2(1, 2)')
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
-  Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '1')
+  Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: null) (OperationKind.Argument, IsInvalid) (Syntax: '1')
       ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
     IArgument (ArgumentKind.Explicit, Matching Parameter: null) (OperationKind.Argument, IsInvalid) (Syntax: '2')
       ILiteralExpression (Text: 2) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: '2')
@@ -975,7 +975,7 @@ void M2(string x )
             string expectedOperationTree = @"
 IInvocationExpression ( void P.M2(System.String x)) (OperationKind.InvocationExpression, Type: System.Void, IsInvalid) (Syntax: 'M2(1)')
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'M2')
-  Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '1')
+  Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: null) (OperationKind.Argument, IsInvalid) (Syntax: '1')
       ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
 ";
             var expectedDiagnostics = new DiagnosticDescription[] 
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_InvalidExpression.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_InvalidExpression.cs
index 89851b7db6eb0..219aaba67737a 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_InvalidExpression.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_InvalidExpression.cs
@@ -60,7 +60,7 @@ void F(int x)
             string expectedOperationTree = @"
 IInvocationExpression ( void Program.F(System.Int32 x)) (OperationKind.InvocationExpression, Type: System.Void, IsInvalid) (Syntax: 'F(string.Empty)')
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Implicit) (OperationKind.InstanceReferenceExpression, Type: Program) (Syntax: 'F')
-  Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: 'string.Empty')
+  Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: null) (OperationKind.Argument, IsInvalid) (Syntax: 'string.Empty')
       IFieldReferenceExpression: System.String System.String.Empty (Static) (OperationKind.FieldReferenceExpression, Type: System.String) (Syntax: 'string.Empty')
 ";
             var expectedDiagnostics = new DiagnosticDescription[] {

From 236790369e2155cb51bf751116a7cd19d8962645 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Fri, 12 May 2017 22:26:53 -0700
Subject: [PATCH 174/284] Fix error after rebase

---
 .../Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs  | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
index 89aa17d7a95a2..889173b25084b 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs
@@ -360,6 +360,7 @@ internal AsyncForwardEntryPoint(CSharpCompilation compilation, NamedTypeSymbol c
                         invokedAsExtensionMethod: false,
                         argsToParamsOpt: default(ImmutableArray<int>),
                         resultKind: LookupResultKind.Viable,
+                        binderOpt: binder,
                         type: userMain.ReturnType)
                 { WasCompilerGenerated = true };
 

From c0d1472709972eee8c416ac6fe9884603fc6e2f7 Mon Sep 17 00:00:00 2001
From: Matt Ellis <matell@microsoft.com>
Date: Fri, 12 May 2017 16:22:58 -0700
Subject: [PATCH 175/284] Pass build configuration when publishing bootstrap
 compiler

Without this, we always end up publishing the debug version of the
compiler.
---
 Makefile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index c407143699ef2..c00e72729f700 100644
--- a/Makefile
+++ b/Makefile
@@ -43,8 +43,8 @@ bootstrap: restore
 	$(BUILD_CMD) src/Compilers/CSharp/CscCore && \
 	$(BUILD_CMD) src/Compilers/VisualBasic/VbcCore && \
 	mkdir -p $(BOOTSTRAP_PATH)/csc && mkdir -p $(BOOTSTRAP_PATH)/vbc && \
-	dotnet publish -r $(RUNTIME_ID) src/Compilers/CSharp/CscCore -o $(BOOTSTRAP_PATH)/csc && \
-	dotnet publish -r $(RUNTIME_ID) src/Compilers/VisualBasic/VbcCore -o $(BOOTSTRAP_PATH)/vbc
+	dotnet publish -c $(BUILD_CONFIGURATION) -r $(RUNTIME_ID) src/Compilers/CSharp/CscCore -o $(BOOTSTRAP_PATH)/csc && \
+	dotnet publish -c $(BUILD_CONFIGURATION) -r $(RUNTIME_ID) src/Compilers/VisualBasic/VbcCore -o $(BOOTSTRAP_PATH)/vbc
 	rm -rf Binaries/$(BUILD_CONFIGURATION)
 
 test:

From 54d97ddd742108b1e971576596539b6b736df4fb Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sat, 13 May 2017 14:29:41 -0700
Subject: [PATCH 176/284] Remove code for generating constructors from
 class-decl, it will be provided by another fixer.

---
 .../GenerateConstructorCodeFixProvider.cs     | 41 ++++---------------
 .../GenerateConstructorCodeFixProvider.vb     | 24 ++++-------
 2 files changed, 16 insertions(+), 49 deletions(-)

diff --git a/src/Features/CSharp/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.cs b/src/Features/CSharp/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.cs
index e7b18c97f106c..cb9c038cbe578 100644
--- a/src/Features/CSharp/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.cs
@@ -1,6 +1,5 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Composition;
 using System.Threading;
@@ -12,7 +11,6 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.GenerateMember.GenerateConstructor;
 using Microsoft.CodeAnalysis.Shared.Extensions;
-using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.CSharp.GenerateConstructor
 {
@@ -46,43 +44,22 @@ protected override Task<ImmutableArray<CodeAction>> GetCodeActionsAsync(
 
         protected override bool IsCandidate(SyntaxNode node, SyntaxToken token, Diagnostic diagnostic)
         {
-            if (node is ObjectCreationExpressionSyntax ||
-                node is ConstructorInitializerSyntax ||
-                node is AttributeSyntax)
-            {
-                return true;
-            }
-
-            return diagnostic.Id == GenerateConstructorDiagnosticIds.CS7036 && 
-                node is ClassDeclarationSyntax && 
-                IsInClassDeclarationHeader((ClassDeclarationSyntax)node, token);
-        }
-
-        private bool IsInClassDeclarationHeader(ClassDeclarationSyntax node, SyntaxToken token)
-        {
-            var start = node.SpanStart;
-            var end = node.BaseList != null
-                ? node.BaseList.Span.End
-                : node.Identifier.Span.End;
-
-            return TextSpan.FromBounds(start, end).Contains(token.Span);
+            return node is ObjectCreationExpressionSyntax ||
+                   node is ConstructorInitializerSyntax ||
+                   node is AttributeSyntax;
         }
 
         protected override SyntaxNode GetTargetNode(SyntaxNode node)
         {
-            var objectCreationNode = node as ObjectCreationExpressionSyntax;
-            if (objectCreationNode != null)
-            {
-                return objectCreationNode.Type.GetRightmostName();
-            }
-
-            var attributeNode = node as AttributeSyntax;
-            if (attributeNode != null)
+            switch (node)
             {
-                return attributeNode.Name;
+                case ObjectCreationExpressionSyntax objectCreationNode:
+                    return objectCreationNode.Type.GetRightmostName();
+                case AttributeSyntax attributeNode:
+                    return attributeNode.Name;
             }
 
             return node;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Features/VisualBasic/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.vb b/src/Features/VisualBasic/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.vb
index 487c4c143389a..98adf9129f224 100644
--- a/src/Features/VisualBasic/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.vb
+++ b/src/Features/VisualBasic/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.vb
@@ -1,13 +1,13 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-Imports System.Threading
 Imports System.Collections.Immutable
+Imports System.Composition
+Imports System.Threading
 Imports Microsoft.CodeAnalysis.CodeActions
 Imports Microsoft.CodeAnalysis.CodeFixes
 Imports Microsoft.CodeAnalysis.CodeFixes.GenerateMember
-Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 Imports Microsoft.CodeAnalysis.GenerateMember.GenerateConstructor
-Imports System.Composition
+Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateConstructor
     Friend Class GenerateConstructorDiagnosticIds
@@ -60,19 +60,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateConstructor
         End Function
 
         Protected Overrides Function IsCandidate(node As SyntaxNode, token As SyntaxToken, diagnostic As Diagnostic) As Boolean
-            If TypeOf node Is InvocationExpressionSyntax OrElse
-               TypeOf node Is ObjectCreationExpressionSyntax OrElse
-               TypeOf node Is AttributeSyntax Then
-                Return True
-            End If
-
-            Return diagnostic.Id = GenerateConstructorDiagnosticIds.BC30387 AndAlso
-                TypeOf node Is ClassBlockSyntax AndAlso
-                IsInClassDeclarationHeader(DirectCast(node, ClassBlockSyntax), token)
-        End Function
-
-        Private Function IsInClassDeclarationHeader(node As ClassBlockSyntax, token As SyntaxToken) As Boolean
-            Return node.ClassStatement.Span.Contains(token.Span)
+            Return TypeOf node Is InvocationExpressionSyntax OrElse
+                   TypeOf node Is ObjectCreationExpressionSyntax OrElse
+                   TypeOf node Is AttributeSyntax
         End Function
     End Class
-End Namespace
+End Namespace
\ No newline at end of file

From 4c2862c19c16bdedddd4cadcf53a7f1d74b749e7 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sat, 13 May 2017 15:10:04 -0700
Subject: [PATCH 177/284] Move delegated constructor responsibility to the
 refactoring provider.

---
 ...SharpGenerateDefaultConstructorsService.cs | 48 +++++++------
 ...uctorFromMembersCodeRefactoringProvider.cs | 18 +----
 ...tConstructorsService.AbstractCodeAction.cs |  4 +-
 ...teDefaultConstructorsService.CodeAction.cs |  2 +-
 ...efaultConstructorsService.CodeActionAll.cs | 13 +---
 ...enerateDefaultConstructorsService.State.cs | 68 +++++++++----------
 ...tractGenerateDefaultConstructorsService.cs | 31 ++++-----
 ...BasicGenerateDefaultConstructorsService.vb | 30 +++++---
 8 files changed, 101 insertions(+), 113 deletions(-)

diff --git a/src/Features/CSharp/Portable/GenerateMember/GenerateDefaultConstructors/CSharpGenerateDefaultConstructorsService.cs b/src/Features/CSharp/Portable/GenerateMember/GenerateDefaultConstructors/CSharpGenerateDefaultConstructorsService.cs
index 03ca328782ad8..2cc803fe7bd7b 100644
--- a/src/Features/CSharp/Portable/GenerateMember/GenerateDefaultConstructors/CSharpGenerateDefaultConstructorsService.cs
+++ b/src/Features/CSharp/Portable/GenerateMember/GenerateDefaultConstructors/CSharpGenerateDefaultConstructorsService.cs
@@ -4,8 +4,10 @@
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.GenerateFromMembers;
 using Microsoft.CodeAnalysis.GenerateMember.GenerateDefaultConstructors;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 
@@ -16,33 +18,41 @@ internal class CSharpGenerateDefaultConstructorsService : AbstractGenerateDefaul
     {
         protected override bool TryInitializeState(
             SemanticDocument document, TextSpan textSpan, CancellationToken cancellationToken,
-            out SyntaxNode baseTypeNode, out INamedTypeSymbol classType)
+            out INamedTypeSymbol classOrStructType)
         {
-            if (!cancellationToken.IsCancellationRequested)
+            cancellationToken.ThrowIfCancellationRequested();
+
+            // Offer the feature if we're on the header for the class/struct, or if we're on the 
+            // first base-type of a class.
+
+            var syntaxFacts = document.Document.GetLanguageService<ISyntaxFactsService>();
+            if (syntaxFacts.IsOnTypeHeader(document.Root, textSpan.Start))
+            {
+                classOrStructType = AbstractGenerateFromMembersCodeRefactoringProvider.GetEnclosingNamedType(
+                    document.SemanticModel, document.Root, textSpan.Start, cancellationToken);
+                return classOrStructType != null;
+            }
+
+            var syntaxTree = document.SyntaxTree;
+            var node = document.Root.FindToken(textSpan.Start).GetAncestor<TypeSyntax>();
+            if (node != null)
             {
-                var syntaxTree = document.SyntaxTree;
-                var node = document.Root.FindToken(textSpan.Start).GetAncestor<TypeSyntax>();
-                if (node != null)
+                if (node.Parent is BaseTypeSyntax && node.Parent.IsParentKind(SyntaxKind.BaseList))
                 {
-                    if (node.Parent is BaseTypeSyntax && node.Parent.IsParentKind(SyntaxKind.BaseList))
+                    var baseList = (BaseListSyntax)node.Parent.Parent;
+                    if (baseList.Types.Count > 0 &&
+                        baseList.Types[0].Type == node &&
+                        baseList.IsParentKind(SyntaxKind.ClassDeclaration))
                     {
-                        var baseList = (BaseListSyntax)node.Parent.Parent;
-                        if (baseList.Types.Count > 0 &&
-                            baseList.Types[0].Type == node &&
-                            baseList.IsParentKind(SyntaxKind.ClassDeclaration))
-                        {
-                            var semanticModel = document.SemanticModel;
-                            classType = semanticModel.GetDeclaredSymbol(baseList.Parent, cancellationToken) as INamedTypeSymbol;
-                            baseTypeNode = node;
-                            return classType != null;
-                        }
+                        var semanticModel = document.SemanticModel;
+                        classOrStructType = semanticModel.GetDeclaredSymbol(baseList.Parent, cancellationToken) as INamedTypeSymbol;
+                        return classOrStructType != null;
                     }
                 }
             }
 
-            baseTypeNode = null;
-            classType = null;
+            classOrStructType = null;
             return false;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Features/Core/Portable/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs b/src/Features/Core/Portable/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs
index e9c64bc7f183b..17ef5f446f6fa 100644
--- a/src/Features/Core/Portable/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs
@@ -93,26 +93,10 @@ private async Task HandleNonSelectionAsync(CodeRefactoringContext context)
 
             // Find all the possible writable instance fields/properties.  If there are any, then
             // show a dialog to the user to select the ones they want.  Otherwise, if there are none
-            // just offer to generate the no-param constructor if they don't already have one.
+            // don't offer to generate anything.
             var viableMembers = containingType.GetMembers().WhereAsArray(IsWritableInstanceFieldOrProperty);
             if (viableMembers.Length == 0)
             {
-                var noParamConstructor = containingType.InstanceConstructors.FirstOrDefault(c => c.Parameters.Length == 0);
-                if (noParamConstructor == null ||
-                    noParamConstructor.IsImplicitlyDeclared)
-                {
-                    // Offer to just make the no-param-constructor directly.
-                    var state = State.TryGenerate(this, document, textSpan, containingType,
-                        ImmutableArray<ISymbol>.Empty, cancellationToken);
-
-                    if (state != null)
-                    {
-                        context.RegisterRefactoring(
-                            new FieldDelegatingCodeAction(this, document, state, addNullChecks: false));
-                    }
-                }
-
-                // already had an explicit, no-param constructor.  No need to offer anything.
                 return;
             }
 
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs
index 22258ba1ee6e1..686e4126edaab 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs
@@ -42,7 +42,7 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
             {
                 var result = await CodeGenerator.AddMemberDeclarationsAsync(
                     _document.Project.Solution,
-                    _state.ClassType,
+                    _state.ClassOrStructType,
                     _constructors.Select(CreateConstructorDefinition),
                     cancellationToken: cancellationToken).ConfigureAwait(false);
 
@@ -61,7 +61,7 @@ private IMethodSymbol CreateConstructorDefinition(
                     attributes: default(ImmutableArray<AttributeData>),
                     accessibility: constructor.DeclaredAccessibility,
                     modifiers: new DeclarationModifiers(),
-                    typeName: _state.ClassType.Name,
+                    typeName: _state.ClassOrStructType.Name,
                     parameters: constructor.Parameters,
                     statements: default(ImmutableArray<SyntaxNode>),
                     baseConstructorArguments: baseConstructorArguments);
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.CodeAction.cs b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.CodeAction.cs
index 9a3eccbb10fe7..8823a08e9f301 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.CodeAction.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.CodeAction.cs
@@ -23,7 +23,7 @@ private static string GetDisplayText(State state, IMethodSymbol constructor)
                 var parameterString = string.Join(", ", parameters);
 
                 return string.Format(FeaturesResources.Generate_constructor_0_1 + ".",
-                    state.ClassType.Name, parameterString);
+                    state.ClassOrStructType.Name, parameterString);
             }
         }
     }
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.CodeActionAll.cs b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.CodeActionAll.cs
index 1eff171a88bf7..92fb8370e5882 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.CodeActionAll.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.CodeActionAll.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Collections.Generic;
-using System.Linq;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.GenerateMember.GenerateDefaultConstructors
 {
@@ -15,16 +13,9 @@ public CodeActionAll(
                 Document document,
                 State state,
                 IList<IMethodSymbol> constructors)
-                : base(service, document, state, GetConstructors(state, constructors), FeaturesResources.Generate_all)
+                : base(service, document, state, constructors, FeaturesResources.Generate_all)
             {
             }
-
-            private static IList<IMethodSymbol> GetConstructors(State state, IList<IMethodSymbol> constructors)
-            {
-                return state.UnimplementedDefaultConstructor != null
-                    ? new[] { state.UnimplementedDefaultConstructor }.Concat(constructors).ToList()
-                    : constructors;
-            }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs
index c3646cb027020..060d71848857a 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs
@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis;
@@ -15,12 +17,9 @@ internal abstract partial class AbstractGenerateDefaultConstructorsService<TServ
     {
         private class State
         {
-            public INamedTypeSymbol ClassType { get; private set; }
+            public INamedTypeSymbol ClassOrStructType { get; private set; }
 
-            public IList<IMethodSymbol> UnimplementedConstructors { get; private set; }
-            public IMethodSymbol UnimplementedDefaultConstructor { get; private set; }
-
-            public SyntaxNode BaseTypeNode { get; private set; }
+            public ImmutableArray<IMethodSymbol> UnimplementedConstructors { get; private set; }
 
             private State()
             {
@@ -47,56 +46,55 @@ private bool TryInitialize(
                 TextSpan textSpan,
                 CancellationToken cancellationToken)
             {
-                if (!service.TryInitializeState(document, textSpan, cancellationToken, out var baseTypeNode, out var classType))
-                {
-                    return false;
-                }
-
-                if (!baseTypeNode.Span.IntersectsWith(textSpan.Start))
+                if (!service.TryInitializeState(document, textSpan, cancellationToken, 
+                        out var classOrStructType))
                 {
                     return false;
                 }
 
-                this.BaseTypeNode = baseTypeNode;
-                this.ClassType = classType;
-
-                var baseType = this.ClassType.BaseType;
+                this.ClassOrStructType = classOrStructType;
 
-                if (this.ClassType.TypeKind != TypeKind.Class ||
-                    this.ClassType.IsStatic ||
+                var baseType = this.ClassOrStructType.BaseType;
+                if (this.ClassOrStructType.IsStatic ||
                     baseType == null ||
-                    baseType.SpecialType == SpecialType.System_Object ||
                     baseType.TypeKind == TypeKind.Error)
                 {
                     return false;
                 }
 
                 var semanticFacts = document.Project.LanguageServices.GetService<ISemanticFactsService>();
-                var classConstructors = this.ClassType.InstanceConstructors;
-                var baseTypeConstructors =
-                    baseType.InstanceConstructors
-                            .Where(c => c.IsAccessibleWithin(this.ClassType));
+                var classConstructors = this.ClassOrStructType.InstanceConstructors;
 
-                var destinationProvider = document.Project.Solution.Workspace.Services.GetLanguageServices(this.ClassType.Language);
+                var destinationProvider = document.Project.Solution.Workspace.Services.GetLanguageServices(this.ClassOrStructType.Language);
                 var syntaxFacts = destinationProvider.GetService<ISyntaxFactsService>();
+                var isCaseSensitive = syntaxFacts.IsCaseSensitive;
 
-                var missingConstructors =
-                    baseTypeConstructors.Where(c1 => !classConstructors.Any(
-                        c2 => SignatureComparer.Instance.HaveSameSignature(c1.Parameters, c2.Parameters, compareParameterName: true, isCaseSensitive: syntaxFacts.IsCaseSensitive))).ToList();
+                this.UnimplementedConstructors =
+                    baseType.InstanceConstructors
+                            .WhereAsArray(c => c.IsAccessibleWithin(this.ClassOrStructType) &&
+                                               IsMissing(c, classConstructors, isCaseSensitive));
 
-                this.UnimplementedConstructors = missingConstructors;
+                return this.UnimplementedConstructors.Length > 0;
+            }
+
+            private bool IsMissing(
+                IMethodSymbol constructor, 
+                ImmutableArray<IMethodSymbol> classConstructors, 
+                bool isCaseSensitive)
+            {
+                var matchingConstructor = classConstructors.FirstOrDefault(
+                    c => SignatureComparer.Instance.HaveSameSignature(
+                        constructor.Parameters, c.Parameters, compareParameterName: true, isCaseSensitive: isCaseSensitive));
 
-                this.UnimplementedDefaultConstructor = baseTypeConstructors.FirstOrDefault(c => c.Parameters.Length == 0);
-                if (this.UnimplementedDefaultConstructor != null)
+                if (matchingConstructor == null)
                 {
-                    if (classConstructors.Any(c => c.Parameters.Length == 0 && !c.IsImplicitlyDeclared))
-                    {
-                        this.UnimplementedDefaultConstructor = null;
-                    }
+                    return true;
                 }
 
-                return this.UnimplementedConstructors.Count > 0;
+                // We have a matching constructor in this type.  But we'll still offer to create the
+                // constructor if the constructor that we have is implicit. 
+                return matchingConstructor.IsImplicitlyDeclared;
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.cs b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.cs
index 7966162f8d76f..80e2bb133f9d4 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.cs
@@ -1,6 +1,5 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
@@ -17,7 +16,7 @@ protected AbstractGenerateDefaultConstructorsService()
         {
         }
 
-        protected abstract bool TryInitializeState(SemanticDocument document, TextSpan textSpan, CancellationToken cancellationToken, out SyntaxNode baseTypeNode, out INamedTypeSymbol classType);
+        protected abstract bool TryInitializeState(SemanticDocument document, TextSpan textSpan, CancellationToken cancellationToken, out INamedTypeSymbol classOrStructType);
 
         public async Task<ImmutableArray<CodeAction>> GenerateDefaultConstructorsAsync(
             Document document,
@@ -28,30 +27,26 @@ public async Task<ImmutableArray<CodeAction>> GenerateDefaultConstructorsAsync(
             {
                 var semanticDocument = await SemanticDocument.CreateAsync(document, cancellationToken).ConfigureAwait(false);
 
+                var result = ArrayBuilder<CodeAction>.GetInstance();
                 if (textSpan.IsEmpty)
                 {
                     var state = State.Generate((TService)this, semanticDocument, textSpan, cancellationToken);
                     if (state != null)
                     {
-                        return GetActions(document, state).AsImmutableOrNull();
+                        foreach (var constructor in state.UnimplementedConstructors)
+                        {
+                            result.Add(new GenerateDefaultConstructorCodeAction((TService)this, document, state, constructor));
+                        }
+
+                        if (state.UnimplementedConstructors.Length > 1)
+                        {
+                            result.Add(new CodeActionAll((TService)this, document, state, state.UnimplementedConstructors));
+                        }
                     }
                 }
 
-                return default(ImmutableArray<CodeAction>);
-            }
-        }
-
-        private IEnumerable<CodeAction> GetActions(Document document, State state)
-        {
-            foreach (var constructor in state.UnimplementedConstructors)
-            {
-                yield return new GenerateDefaultConstructorCodeAction((TService)this, document, state, constructor);
-            }
-
-            if (state.UnimplementedConstructors.Count > 1)
-            {
-                yield return new CodeActionAll((TService)this, document, state, state.UnimplementedConstructors);
+                return result.ToImmutableAndFree();
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Features/VisualBasic/Portable/GenerateMember/GenerateDefaultConstructors/VisualBasicGenerateDefaultConstructorsService.vb b/src/Features/VisualBasic/Portable/GenerateMember/GenerateDefaultConstructors/VisualBasicGenerateDefaultConstructorsService.vb
index 531cb88965a9e..e23bb0386e8e9 100644
--- a/src/Features/VisualBasic/Portable/GenerateMember/GenerateDefaultConstructors/VisualBasicGenerateDefaultConstructorsService.vb
+++ b/src/Features/VisualBasic/Portable/GenerateMember/GenerateDefaultConstructors/VisualBasicGenerateDefaultConstructorsService.vb
@@ -2,8 +2,10 @@
 
 Imports System.Composition
 Imports System.Threading
+Imports Microsoft.CodeAnalysis.GenerateFromMembers
 Imports Microsoft.CodeAnalysis.GenerateMember.GenerateDefaultConstructors
 Imports Microsoft.CodeAnalysis.Host.Mef
+Imports Microsoft.CodeAnalysis.LanguageServices
 Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
@@ -14,28 +16,36 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateMember.GenerateDefaultConst
 
         Protected Overrides Function TryInitializeState(
                 document As SemanticDocument, textSpan As TextSpan, cancellationToken As CancellationToken,
-                ByRef baseTypeNode As SyntaxNode, ByRef classType As INamedTypeSymbol) As Boolean
-            If cancellationToken.IsCancellationRequested Then
-                Return False
+                ByRef classOrStructType As INamedTypeSymbol) As Boolean
+            cancellationToken.ThrowIfCancellationRequested()
+
+            ' Offer the feature if we're on the header for the class/struct, or if we're on the 
+            ' first base-type of a class.
+
+            Dim syntaxFacts = document.Document.GetLanguageService(Of ISyntaxFactsService)()
+            If syntaxFacts.IsOnTypeHeader(document.Root, textSpan.Start) Then
+                classOrStructType = AbstractGenerateFromMembersCodeRefactoringProvider.GetEnclosingNamedType(
+                    document.SemanticModel, document.Root, textSpan.Start, cancellationToken)
+                Return classOrStructType IsNot Nothing
             End If
 
-            Dim token = DirectCast(document.Root, SyntaxNode).FindToken(textSpan.Start)
+            Dim token = document.Root.FindToken(textSpan.Start)
 
             Dim type = token.GetAncestor(Of TypeSyntax)()
             If type IsNot Nothing AndAlso type.IsParentKind(SyntaxKind.InheritsStatement) Then
                 Dim baseList = DirectCast(type.Parent, InheritsStatementSyntax)
+
                 If baseList.Types.Count > 0 AndAlso
                    baseList.Types(0) Is type AndAlso
                    baseList.IsParentKind(SyntaxKind.ClassBlock) Then
-                    classType = TryCast(document.SemanticModel.GetDeclaredSymbol(baseList.Parent, cancellationToken), INamedTypeSymbol)
-                    baseTypeNode = type
-                    Return classType IsNot Nothing
+
+                    classOrStructType = TryCast(document.SemanticModel.GetDeclaredSymbol(baseList.Parent, cancellationToken), INamedTypeSymbol)
+                    Return classOrStructType IsNot Nothing
                 End If
             End If
 
-            baseTypeNode = Nothing
-            classType = Nothing
+            classOrStructType = Nothing
             Return False
         End Function
     End Class
-End Namespace
+End Namespace
\ No newline at end of file

From c81dfd31b343b5224b894c972ce1773a97d5d9a6 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sat, 13 May 2017 15:19:48 -0700
Subject: [PATCH 178/284] Remove unneeded code.

---
 .../BasicEditorServicesTest.vbproj            |  4 +-
 .../GenerateConstructorTests.vb               |  3 +-
 .../GenerateDefaultConstructorsTests.vb       |  3 +-
 .../CSharpGenerateConstructorService.cs       | 42 +------------------
 ...bstractGenerateConstructorService.State.cs | 26 ------------
 .../AbstractGenerateConstructorService.cs     |  2 -
 .../VisualBasicGenerateConstructorService.vb  | 27 ------------
 7 files changed, 8 insertions(+), 99 deletions(-)
 rename src/EditorFeatures/VisualBasicTest/{Diagnostics => }/GenerateConstructor/GenerateConstructorTests.vb (99%)
 rename src/EditorFeatures/VisualBasicTest/{CodeActions => }/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb (98%)

diff --git a/src/EditorFeatures/VisualBasicTest/BasicEditorServicesTest.vbproj b/src/EditorFeatures/VisualBasicTest/BasicEditorServicesTest.vbproj
index 5960dd18eb7f3..00b590be83690 100644
--- a/src/EditorFeatures/VisualBasicTest/BasicEditorServicesTest.vbproj
+++ b/src/EditorFeatures/VisualBasicTest/BasicEditorServicesTest.vbproj
@@ -227,7 +227,7 @@
     <Compile Include="ConvertToInterpolatedString\ConvertPlaceholderToInterpolatedStringTests.vb" />
     <Compile Include="CodeActions\EncapsulateField\EncapsulateFieldTests.vb" />
     <Compile Include="CodeActions\ExtractMethod\ExtractMethodTests.vb" />
-    <Compile Include="CodeActions\GenerateDefaultConstructors\GenerateDefaultConstructorsTests.vb" />
+    <Compile Include="GenerateDefaultConstructors\GenerateDefaultConstructorsTests.vb" />
     <Compile Include="AddConstructorParametersFromMembers\AddConstructorParametersFromMembersTests.vb" />
     <Compile Include="GenerateConstructorFromMembers\GenerateConstructorFromMembersTests.vb" />
     <Compile Include="GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersTests.vb" />
@@ -276,7 +276,7 @@
     <Compile Include="Diagnostics\ExitContinue\ExitContinueCodeActionTests.vb" />
     <Compile Include="Diagnostics\FixIncorrectFunctionReturnType\FixIncorrectFunctionReturnTypeTests.vb" />
     <Compile Include="Diagnostics\FullyQualify\FullyQualifyTests.vb" />
-    <Compile Include="Diagnostics\GenerateConstructor\GenerateConstructorTests.vb" />
+    <Compile Include="GenerateConstructor\GenerateConstructorTests.vb" />
     <Compile Include="Diagnostics\GenerateEndConstruct\GenerateEndConstructTests.vb" />
     <Compile Include="Diagnostics\GenerateEnumMember\GenerateEnumMemberTests.vb" />
     <Compile Include="Diagnostics\GenerateEvent\GenerateEventTests.vb" />
diff --git a/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateConstructor/GenerateConstructorTests.vb b/src/EditorFeatures/VisualBasicTest/GenerateConstructor/GenerateConstructorTests.vb
similarity index 99%
rename from src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateConstructor/GenerateConstructorTests.vb
rename to src/EditorFeatures/VisualBasicTest/GenerateConstructor/GenerateConstructorTests.vb
index aacc36e69565d..3fe508606bfd9 100644
--- a/src/EditorFeatures/VisualBasicTest/Diagnostics/GenerateConstructor/GenerateConstructorTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/GenerateConstructor/GenerateConstructorTests.vb
@@ -2,10 +2,11 @@
 
 Imports Microsoft.CodeAnalysis.CodeFixes
 Imports Microsoft.CodeAnalysis.Diagnostics
+Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics
 Imports Microsoft.CodeAnalysis.VisualBasic.Diagnostics
 Imports Microsoft.CodeAnalysis.VisualBasic.GenerateConstructor
 
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics.GenerateConstructor
+Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.GenerateConstructor
     Public Class GenerateConstructorTests
         Inherits AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest
 
diff --git a/src/EditorFeatures/VisualBasicTest/CodeActions/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb b/src/EditorFeatures/VisualBasicTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb
similarity index 98%
rename from src/EditorFeatures/VisualBasicTest/CodeActions/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb
rename to src/EditorFeatures/VisualBasicTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb
index 831a6f8f698cc..821541d2e2749 100644
--- a/src/EditorFeatures/VisualBasicTest/CodeActions/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb
@@ -2,8 +2,9 @@
 
 Imports Microsoft.CodeAnalysis.CodeRefactorings
 Imports Microsoft.CodeAnalysis.CodeRefactorings.GenerateDefaultConstructors
+Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings
 
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings.GenerateDefaultConstructors
+Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.GenerateDefaultConstructors
     Public Class GenerateDefaultConstructorsTests
         Inherits AbstractVisualBasicCodeActionTest
 
diff --git a/src/Features/CSharp/Portable/GenerateConstructor/CSharpGenerateConstructorService.cs b/src/Features/CSharp/Portable/GenerateConstructor/CSharpGenerateConstructorService.cs
index 93679a43412f1..4943a66b121d9 100644
--- a/src/Features/CSharp/Portable/GenerateConstructor/CSharpGenerateConstructorService.cs
+++ b/src/Features/CSharp/Portable/GenerateConstructor/CSharpGenerateConstructorService.cs
@@ -21,19 +21,10 @@ internal class CSharpGenerateConstructorService : AbstractGenerateConstructorSer
         private static readonly SyntaxAnnotation s_annotation = new SyntaxAnnotation();
 
         protected override bool IsSimpleNameGeneration(SemanticDocument document, SyntaxNode node, CancellationToken cancellationToken)
-        {
-            return node is SimpleNameSyntax;
-        }
+            => node is SimpleNameSyntax;
 
         protected override bool IsConstructorInitializerGeneration(SemanticDocument document, SyntaxNode node, CancellationToken cancellationToken)
-        {
-            return node is ConstructorInitializerSyntax;
-        }
-
-        protected override bool IsClassDeclarationGeneration(SemanticDocument document, SyntaxNode node, CancellationToken cancellationToken)
-        {
-            return node is ClassDeclarationSyntax;
-        }
+            => node is ConstructorInitializerSyntax;
 
         protected override bool TryInitializeConstructorInitializerGeneration(
             SemanticDocument document, SyntaxNode node, CancellationToken cancellationToken,
@@ -60,35 +51,6 @@ protected override bool TryInitializeConstructorInitializerGeneration(
             return false;
         }
 
-        protected override bool TryInitializeClassDeclarationGenerationState(
-            SemanticDocument document,
-            SyntaxNode node,
-            CancellationToken cancellationToken,
-            out SyntaxToken token,
-            out IMethodSymbol delegatedConstructor,
-            out INamedTypeSymbol typeToGenerateIn)
-        {
-            token = default(SyntaxToken);
-            typeToGenerateIn = null;
-            delegatedConstructor = null;
-
-            var semanticModel = document.SemanticModel;
-            var classDeclaration = (ClassDeclarationSyntax)node;
-            var classSymbol = semanticModel.GetDeclaredSymbol(classDeclaration, cancellationToken);
-
-            var baseType = classSymbol.BaseType;
-            var constructor = baseType.Constructors.FirstOrDefault(c => IsSymbolAccessible(c, document));
-            if (constructor == null)
-            {
-                return false;
-            }
-
-            typeToGenerateIn = classSymbol;
-            delegatedConstructor = constructor;
-            token = classDeclaration.Identifier;
-            return true;
-        }
-
         protected override bool TryInitializeSimpleNameGenerationState(
             SemanticDocument document,
             SyntaxNode node,
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.State.cs b/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.State.cs
index cc33c4c0cc849..adcd89487a43c 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.State.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.State.cs
@@ -74,13 +74,6 @@ private async Task<bool> TryInitializeAsync(
                         return false;
                     }
                 }
-                else if (service.IsClassDeclarationGeneration(document, node, cancellationToken))
-                {
-                    if (!await TryInitializeClassDeclarationGenerationAsync(service, document, node, cancellationToken).ConfigureAwait(false))
-                    {
-                        return false;
-                    }
-                }
                 else
                 {
                     return false;
@@ -196,25 +189,6 @@ private async Task<bool> TryInitializeConstructorInitializerGenerationAsync(
                 return await TryDetermineTypeToGenerateInAsync(document, typeToGenerateIn, cancellationToken).ConfigureAwait(false);
             }
 
-            private async Task<bool> TryInitializeClassDeclarationGenerationAsync(
-                TService service,
-                SemanticDocument document,
-                SyntaxNode simpleName,
-                CancellationToken cancellationToken)
-            {
-                if (service.TryInitializeClassDeclarationGenerationState(document, simpleName, cancellationToken,
-                    out var token, out var constructor, out var typeToGenerateIn))
-                {
-                    this.Token = token;
-                    this.DelegatedConstructorOpt = constructor;
-                    this.ParameterTypes = constructor.Parameters.Select(p => p.Type).ToImmutableArray();
-                    this.ParameterRefKinds = constructor.Parameters.Select(p => p.RefKind).ToList();
-                }
-                cancellationToken.ThrowIfCancellationRequested();
-
-                return await TryDetermineTypeToGenerateInAsync(document, typeToGenerateIn, cancellationToken).ConfigureAwait(false);
-            }
-
             private async Task<bool> TryInitializeSimpleNameGenerationAsync(
                 TService service,
                 SemanticDocument document,
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.cs b/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.cs
index 7fc0642d8f9e1..b5faddef6ff11 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.cs
@@ -23,11 +23,9 @@ protected AbstractGenerateConstructorService()
         }
 
         protected abstract bool IsSimpleNameGeneration(SemanticDocument document, SyntaxNode node, CancellationToken cancellationToken);
-        protected abstract bool IsClassDeclarationGeneration(SemanticDocument document, SyntaxNode node, CancellationToken cancellationToken);
         protected abstract bool IsConstructorInitializerGeneration(SemanticDocument document, SyntaxNode node, CancellationToken cancellationToken);
 
         protected abstract bool TryInitializeSimpleNameGenerationState(SemanticDocument document, SyntaxNode simpleName, CancellationToken cancellationToken, out SyntaxToken token, out ImmutableArray<TArgumentSyntax> arguments, out INamedTypeSymbol typeToGenerateIn);
-        protected abstract bool TryInitializeClassDeclarationGenerationState(SemanticDocument document, SyntaxNode classDeclaration, CancellationToken cancellationToken, out SyntaxToken token, out IMethodSymbol constructor, out INamedTypeSymbol typeToGenerateIn);
         protected abstract bool TryInitializeConstructorInitializerGeneration(SemanticDocument document, SyntaxNode constructorInitializer, CancellationToken cancellationToken, out SyntaxToken token, out ImmutableArray<TArgumentSyntax> arguments, out INamedTypeSymbol typeToGenerateIn);
         protected abstract bool TryInitializeSimpleAttributeNameGenerationState(SemanticDocument document, SyntaxNode simpleName, CancellationToken cancellationToken, out SyntaxToken token, out ImmutableArray<TArgumentSyntax> arguments, out ImmutableArray<TAttributeArgumentSyntax> attributeArguments, out INamedTypeSymbol typeToGenerateIn);
         protected abstract ImmutableArray<ParameterName> GenerateParameterNames(SemanticModel semanticModel, IEnumerable<TArgumentSyntax> arguments, IList<string> reservedNames, CancellationToken cancellationToken);
diff --git a/src/Features/VisualBasic/Portable/GenerateConstructor/VisualBasicGenerateConstructorService.vb b/src/Features/VisualBasic/Portable/GenerateConstructor/VisualBasicGenerateConstructorService.vb
index d38bade0703ae..87a6ecf3cf1da 100644
--- a/src/Features/VisualBasic/Portable/GenerateConstructor/VisualBasicGenerateConstructorService.vb
+++ b/src/Features/VisualBasic/Portable/GenerateConstructor/VisualBasicGenerateConstructorService.vb
@@ -154,33 +154,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateConstructor
             Return compilation.ClassifyConversion(sourceType, targetType).IsWidening
         End Function
 
-        Protected Overrides Function IsClassDeclarationGeneration(document As SemanticDocument,
-                                                                  node As SyntaxNode,
-                                                                  cancellationToken As CancellationToken) As Boolean
-            Return TypeOf node Is ClassBlockSyntax
-        End Function
-
-        Protected Overrides Function TryInitializeClassDeclarationGenerationState(
-                document As SemanticDocument,
-                classDeclaration As SyntaxNode,
-                cancellationToken As CancellationToken,
-                ByRef token As SyntaxToken,
-                ByRef delegatedConstructor As IMethodSymbol,
-                ByRef typeToGenerateIn As INamedTypeSymbol) As Boolean
-            Dim semanticModel = document.SemanticModel
-            Dim classBlock = DirectCast(classDeclaration, ClassBlockSyntax)
-            Dim classSymbol = semanticModel.GetDeclaredSymbol(classBlock.BlockStatement, cancellationToken)
-            Dim constructor = classSymbol?.BaseType?.Constructors.FirstOrDefault(Function(c) IsSymbolAccessible(c, document))
-            If constructor Is Nothing Then
-                Return False
-            End If
-
-            typeToGenerateIn = classSymbol
-            delegatedConstructor = constructor
-            token = classBlock.BlockStatement.Identifier
-            Return True
-        End Function
-
         Private Shared ReadOnly s_annotation As SyntaxAnnotation = New SyntaxAnnotation
 
         Friend Overrides Function GetDelegatingConstructor(state As State,

From 5865073828113c6dc96c73fc8eef421cc1f3373d Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sat, 13 May 2017 15:21:11 -0700
Subject: [PATCH 179/284] Don't add punctuation in code.

---
 .../AbstractGenerateDefaultConstructorsService.CodeAction.cs  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.CodeAction.cs b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.CodeAction.cs
index 8823a08e9f301..abc382700e647 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.CodeAction.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.CodeAction.cs
@@ -22,9 +22,9 @@ private static string GetDisplayText(State state, IMethodSymbol constructor)
                 var parameters = constructor.Parameters.Select(p => p.Name);
                 var parameterString = string.Join(", ", parameters);
 
-                return string.Format(FeaturesResources.Generate_constructor_0_1 + ".",
+                return string.Format(FeaturesResources.Generate_constructor_0_1,
                     state.ClassOrStructType.Name, parameterString);
             }
         }
     }
-}
+}
\ No newline at end of file

From a315a6494ea7c134a705cd4c0db8821e48b0ddbf Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sat, 13 May 2017 15:34:18 -0700
Subject: [PATCH 180/284] Fixup VB tests.

---
 .../GenerateConstructorTests.vb               |  92 ----------
 .../GenerateDefaultConstructorsTests.vb       | 159 ++++++++++++++++--
 2 files changed, 146 insertions(+), 105 deletions(-)

diff --git a/src/EditorFeatures/VisualBasicTest/GenerateConstructor/GenerateConstructorTests.vb b/src/EditorFeatures/VisualBasicTest/GenerateConstructor/GenerateConstructorTests.vb
index 3fe508606bfd9..65940a349c416 100644
--- a/src/EditorFeatures/VisualBasicTest/GenerateConstructor/GenerateConstructorTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/GenerateConstructor/GenerateConstructorTests.vb
@@ -1529,98 +1529,6 @@ End Class")
             End Function
         End Class
 
-        <WorkItem(6541, "https://github.com/dotnet/Roslyn/issues/6541")>
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
-        Public Async Function TestGenerateInDerivedType1() As Task
-            Await TestInRegularAndScriptAsync(
-"
-Public Class Base
-    Public Sub New(a As String)
-
-    End Sub
-End Class
-
-Public Class [||]Derived
-    Inherits Base
-
-End Class",
-"
-Public Class Base
-    Public Sub New(a As String)
-
-    End Sub
-End Class
-
-Public Class Derived
-    Inherits Base
-
-    Public Sub New(a As String)
-        MyBase.New(a)
-    End Sub
-End Class")
-        End Function
-
-        <WorkItem(6541, "https://github.com/dotnet/Roslyn/issues/6541")>
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
-        Public Async Function TestGenerateInDerivedType2() As Task
-            Await TestInRegularAndScriptAsync(
-"
-Public Class Base
-    Public Sub New(a As Integer, Optional b As String = Nothing)
-
-    End Sub
-End Class
-
-Public Class [||]Derived
-    Inherits Base
-
-End Class",
-"
-Public Class Base
-    Public Sub New(a As Integer, Optional b As String = Nothing)
-
-    End Sub
-End Class
-
-Public Class Derived
-    Inherits Base
-
-    Public Sub New(a As Integer, Optional b As String = Nothing)
-        MyBase.New(a, b)
-    End Sub
-End Class")
-        End Function
-
-        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
-        Public Async Function TestGenerateInDerivedType_InvalidClassStatement() As Task
-            Await TestInRegularAndScriptAsync(
-"
-Public Class Base
-    Public Sub New(a As Integer, Optional b As String = Nothing)
-
-    End Sub
-End Class
-
-Public Class [|;;|]Derived
-    Inherits Base
-
-End Class",
-"
-Public Class Base
-    Public Sub New(a As Integer, Optional b As String = Nothing)
-
-    End Sub
-End Class
-
-Public Class ;;Derived
-    Inherits Base
-
-    Public Sub New(a As Integer, Optional b As String = Nothing)
-        MyBase.New(a, b)
-    End Sub
-End Class")
-        End Function
-
         <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
         Public Async Function TestGenerateConstructorNotOfferedForDuplicate() As Task
             Await TestMissingInRegularAndScriptAsync(
diff --git a/src/EditorFeatures/VisualBasicTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb b/src/EditorFeatures/VisualBasicTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb
index 821541d2e2749..d121ff837c8c2 100644
--- a/src/EditorFeatures/VisualBasicTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb
@@ -28,8 +28,7 @@ Imports System.Collections.Generic
 Imports System.Linq
 Class Program
     Inherits Exception
-    Public Sub New(message As String)
-        MyBase.New(message)
+    Public Sub New()
     End Sub
     Sub Main(args As String())
     End Sub
@@ -52,8 +51,8 @@ Imports System.Collections.Generic
 Imports System.Linq
 Class Program
     Inherits Exception
-    Public Sub New(message As String, innerException As Exception)
-        MyBase.New(message, innerException)
+    Public Sub New(message As String)
+        MyBase.New(message)
     End Sub
     Sub Main(args As String())
     End Sub
@@ -75,20 +74,50 @@ End Class",
 "Imports System
 Imports System.Collections.Generic
 Imports System.Linq
+
+Class Program
+    Inherits Exception
+
+    Public Sub New(message As String, innerException As Exception)
+        MyBase.New(message, innerException)
+    End Sub
+
+    Sub Main(args As String())
+    End Sub
+End Class",
+index:=2)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)>
+        Public Async Function TestException3() As Task
+            Await TestInRegularAndScriptAsync(
+"Imports System
+Imports System.Collections.Generic
+Imports System.Linq
+Class Program
+    Inherits [||]Exception
+    Sub Main(args As String())
+    End Sub
+End Class",
+"Imports System
+Imports System.Collections.Generic
+Imports System.Linq
 Imports System.Runtime.Serialization
 Class Program
     Inherits Exception
+
     Protected Sub New(info As SerializationInfo, context As StreamingContext)
         MyBase.New(info, context)
     End Sub
+
     Sub Main(args As String())
     End Sub
 End Class",
-index:=2)
+index:=3)
         End Function
 
         <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)>
-        Public Async Function TestException3() As Task
+        Public Async Function TestException4() As Task
             Await TestInRegularAndScriptAsync(
 "Imports System
 Imports System.Collections.Generic
@@ -102,33 +131,47 @@ End Class",
 Imports System.Collections.Generic
 Imports System.Linq
 Imports System.Runtime.Serialization
+
 Class Program
     Inherits Exception
+
     Public Sub New()
     End Sub
+
     Public Sub New(message As String)
         MyBase.New(message)
     End Sub
+
     Public Sub New(message As String, innerException As Exception)
         MyBase.New(message, innerException)
     End Sub
+
     Protected Sub New(info As SerializationInfo, context As StreamingContext)
         MyBase.New(info, context)
     End Sub
+
     Sub Main(args As String())
     End Sub
 End Class",
-index:=3)
+index:=4)
         End Function
 
         <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateDefaultConstructors)>
         <WorkItem(539676, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539676")>
         Public Async Function TestNotOfferedOnResolvedBaseClassName() As Task
-            Await TestMissingInRegularAndScriptAsync(
+            Await TestInRegularAndScript1Async(
 "Class Base
 End Class
 Class Derived
     Inherits B[||]ase
+End Class",
+"Class Base
+End Class
+Class Derived
+    Inherits Base
+
+    Public Sub New()
+    End Sub
 End Class")
         End Function
 
@@ -253,8 +296,7 @@ Imports System.Collections.Generic
 Imports System.Linq
 Class Program
     Inherits Exception
-    Public Sub New()
-    End Sub
+
     Public Sub New()
     End Sub
     Public Sub New(message As String)
@@ -289,8 +331,7 @@ Imports System.Collections.Generic
 Imports System.Linq
 Class Program
     Inherits Exception
-    Public Sub New(message As String)
-        MyBase.New(message)
+    Public Sub New()
     End Sub
     Sub Main(args As String())
     End Sub
@@ -485,5 +526,97 @@ End Class
 index:=2,
 ignoreTrivia:=False)
         End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
+        Public Async Function TestGenerateInDerivedType_InvalidClassStatement() As Task
+            Await TestInRegularAndScriptAsync(
+"
+Public Class Base
+    Public Sub New(a As Integer, Optional b As String = Nothing)
+
+    End Sub
+End Class
+
+Public [||]Class ;;Derived
+    Inherits Base
+
+End Class",
+"
+Public Class Base
+    Public Sub New(a As Integer, Optional b As String = Nothing)
+
+    End Sub
+End Class
+
+Public Class ;;Derived
+    Inherits Base
+
+    Public Sub New(a As Integer, Optional b As String = Nothing)
+        MyBase.New(a, b)
+    End Sub
+End Class")
+        End Function
+
+        <WorkItem(6541, "https://github.com/dotnet/Roslyn/issues/6541")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
+        Public Async Function TestGenerateInDerivedType1() As Task
+            Await TestInRegularAndScriptAsync(
+"
+Public Class Base
+    Public Sub New(a As String)
+
+    End Sub
+End Class
+
+Public Class [||]Derived
+    Inherits Base
+
+End Class",
+"
+Public Class Base
+    Public Sub New(a As String)
+
+    End Sub
+End Class
+
+Public Class Derived
+    Inherits Base
+
+    Public Sub New(a As String)
+        MyBase.New(a)
+    End Sub
+End Class")
+        End Function
+
+        <WorkItem(6541, "https://github.com/dotnet/Roslyn/issues/6541")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)>
+        Public Async Function TestGenerateInDerivedType2() As Task
+            Await TestInRegularAndScriptAsync(
+"
+Public Class Base
+    Public Sub New(a As Integer, Optional b As String = Nothing)
+
+    End Sub
+End Class
+
+Public Class [||]Derived
+    Inherits Base
+
+End Class",
+"
+Public Class Base
+    Public Sub New(a As Integer, Optional b As String = Nothing)
+
+    End Sub
+End Class
+
+Public Class Derived
+    Inherits Base
+
+    Public Sub New(a As Integer, Optional b As String = Nothing)
+        MyBase.New(a, b)
+    End Sub
+End Class")
+        End Function
     End Class
-End Namespace
+End Namespace
\ No newline at end of file

From 82373c8fb5f8f72c1e717277a8f7669abcec3496 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sat, 13 May 2017 15:35:39 -0700
Subject: [PATCH 181/284] Move type.

---
 src/Features/Core/Portable/Features.csproj                      | 2 +-
 .../GenerateDefaultConstructorsCodeRefactoringProvider.cs       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename src/Features/Core/Portable/{CodeRefactorings => }/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs (95%)

diff --git a/src/Features/Core/Portable/Features.csproj b/src/Features/Core/Portable/Features.csproj
index cff5327a8c52d..f0392415bc4d6 100644
--- a/src/Features/Core/Portable/Features.csproj
+++ b/src/Features/Core/Portable/Features.csproj
@@ -323,7 +323,7 @@
     <Compile Include="CodeRefactorings\CodeRefactoringService.cs" />
     <Compile Include="ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs" />
     <Compile Include="CodeRefactorings\ExtractMethod\AbstractExtractMethodCodeRefactoringProvider.cs" />
-    <Compile Include="CodeRefactorings\GenerateDefaultConstructors\GenerateDefaultConstructorsCodeRefactoringProvider.cs" />
+    <Compile Include="GenerateDefaultConstructors\GenerateDefaultConstructorsCodeRefactoringProvider.cs" />
     <Compile Include="AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs" />
     <Compile Include="GenerateConstructorFromMembers\GenerateConstructorFromMembersCodeRefactoringProvider.cs" />
     <Compile Include="GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs" />
diff --git a/src/Features/Core/Portable/CodeRefactorings/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs b/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
similarity index 95%
rename from src/Features/Core/Portable/CodeRefactorings/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
rename to src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
index 25ad0e52fa5a7..7af17362cb3ff 100644
--- a/src/Features/Core/Portable/CodeRefactorings/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
@@ -5,7 +5,7 @@
 using Microsoft.CodeAnalysis.GenerateMember.GenerateDefaultConstructors;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 
-namespace Microsoft.CodeAnalysis.CodeRefactorings.GenerateDefaultConstructors
+namespace Microsoft.CodeAnalysis.GenerateDefaultConstructors
 {
     [ExportCodeRefactoringProvider(LanguageNames.CSharp, LanguageNames.VisualBasic,
         Name = PredefinedCodeRefactoringProviderNames.GenerateDefaultConstructors), Shared]

From 62705b3f98febe6ea6a7cb0ad17b7ad011d8901f Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sat, 13 May 2017 15:37:37 -0700
Subject: [PATCH 182/284] Fixup test code.

---
 .../GenerateDefaultConstructorsTests.vb                         | 2 +-
 .../GenerateDefaultConstructorsCodeRefactoringProvider.cs       | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/VisualBasicTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb b/src/EditorFeatures/VisualBasicTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb
index d121ff837c8c2..c663f0743d3d4 100644
--- a/src/EditorFeatures/VisualBasicTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.vb
@@ -1,8 +1,8 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports Microsoft.CodeAnalysis.CodeRefactorings
-Imports Microsoft.CodeAnalysis.CodeRefactorings.GenerateDefaultConstructors
 Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings
+Imports Microsoft.CodeAnalysis.GenerateDefaultConstructors
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.GenerateDefaultConstructors
     Public Class GenerateDefaultConstructorsTests
diff --git a/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs b/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
index 7af17362cb3ff..50efc3e4fdbba 100644
--- a/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
@@ -2,6 +2,7 @@
 
 using System.Composition;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.GenerateMember.GenerateDefaultConstructors;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 

From fac36fe8af6524532478f8c5bc72ca77a6403614 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sat, 13 May 2017 15:39:16 -0700
Subject: [PATCH 183/284] Fixup C# test code.

---
 .../CSharpTest/CSharpEditorServicesTest.csproj               | 2 +-
 .../GenerateDefaultConstructorsTests.cs                      | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)
 rename src/EditorFeatures/CSharpTest/{CodeActions => }/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs (98%)

diff --git a/src/EditorFeatures/CSharpTest/CSharpEditorServicesTest.csproj b/src/EditorFeatures/CSharpTest/CSharpEditorServicesTest.csproj
index 24d00d4664012..fe91a8949ad67 100644
--- a/src/EditorFeatures/CSharpTest/CSharpEditorServicesTest.csproj
+++ b/src/EditorFeatures/CSharpTest/CSharpEditorServicesTest.csproj
@@ -246,7 +246,7 @@
     <Compile Include="ConvertToInterpolatedString\ConvertPlaceholderToInterpolatedStringTests.cs" />
     <Compile Include="CodeActions\EncapsulateField\EncapsulateFieldTests.cs" />
     <Compile Include="CodeActions\ExtractMethod\ExtractMethodTests.cs" />
-    <Compile Include="CodeActions\GenerateDefaultConstructors\GenerateDefaultConstructorsTests.cs" />
+    <Compile Include="GenerateDefaultConstructors\GenerateDefaultConstructorsTests.cs" />
     <Compile Include="Diagnostics\UpgradeProject\UpgradeProjectTests.cs" />
     <Compile Include="Completion\CompletionProviders\DeclarationNameCompletionProviderTests_NameDeclarationInfoTests.cs" />
     <Compile Include="GenerateFromMembers\AddConstructorParametersFromMembers\AddConstructorParametersFromMembersTests.cs" />
diff --git a/src/EditorFeatures/CSharpTest/CodeActions/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs b/src/EditorFeatures/CSharpTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs
similarity index 98%
rename from src/EditorFeatures/CSharpTest/CodeActions/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs
rename to src/EditorFeatures/CSharpTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs
index ee5148980a810..498bd8e05fc14 100644
--- a/src/EditorFeatures/CSharpTest/CodeActions/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs
+++ b/src/EditorFeatures/CSharpTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs
@@ -2,11 +2,12 @@
 
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeRefactorings;
-using Microsoft.CodeAnalysis.CodeRefactorings.GenerateDefaultConstructors;
+using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings;
+using Microsoft.CodeAnalysis.GenerateDefaultConstructors;
 using Roslyn.Test.Utilities;
 using Xunit;
 
-namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings.GenerateDefaultConstructors
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.GenerateDefaultConstructors
 {
     public class GenerateDefaultConstructorsTests : AbstractCSharpCodeActionTest
     {

From c46b37e254495e07030d47f2725365ddff40017e Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sat, 13 May 2017 15:52:46 -0700
Subject: [PATCH 184/284] Fixup C# tests.

---
 .../GenerateConstructorTests.cs               | 60 -----------------
 .../GenerateDefaultConstructorsTests.cs       | 66 +++++++++++++++++--
 2 files changed, 61 insertions(+), 65 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/GenerateConstructor/GenerateConstructorTests.cs b/src/EditorFeatures/CSharpTest/GenerateConstructor/GenerateConstructorTests.cs
index 3a7fb7ee22d11..93f140796a68f 100644
--- a/src/EditorFeatures/CSharpTest/GenerateConstructor/GenerateConstructorTests.cs
+++ b/src/EditorFeatures/CSharpTest/GenerateConstructor/GenerateConstructorTests.cs
@@ -2316,66 +2316,6 @@ public Base(bool val = false)
 }");
         }
 
-        [WorkItem(6541, "https://github.com/dotnet/Roslyn/issues/6541")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
-        public async Task TestGenerateFromDerivedClass()
-        {
-            await TestInRegularAndScriptAsync(
-@"class Base
-{
-    public Base(string value)
-    {
-    }
-}
-
-class [||]Derived : Base
-{
-}",
-@"class Base
-{
-    public Base(string value)
-    {
-    }
-}
-
-class Derived : Base
-{
-    public Derived(string value) : base(value)
-    {
-    }
-}");
-        }
-
-        [WorkItem(6541, "https://github.com/dotnet/Roslyn/issues/6541")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
-        public async Task TestGenerateFromDerivedClass2()
-        {
-            await TestInRegularAndScriptAsync(
-@"class Base
-{
-    public Base(int a, string value = null)
-    {
-    }
-}
-
-class [||]Derived : Base
-{
-}",
-@"class Base
-{
-    public Base(int a, string value = null)
-    {
-    }
-}
-
-class Derived : Base
-{
-    public Derived(int a, string value = null) : base(a, value)
-    {
-    }
-}");
-        }
-
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
         public async Task TestGenerateWithIncorrectConstructorArguments_Crash()
         {
diff --git a/src/EditorFeatures/CSharpTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs b/src/EditorFeatures/CSharpTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs
index 498bd8e05fc14..a3b96fdbd1115 100644
--- a/src/EditorFeatures/CSharpTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs
+++ b/src/EditorFeatures/CSharpTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs
@@ -591,7 +591,7 @@ protected Program(SerializationInfo info, StreamingContext context) : base(info,
     {
     }
 }",
-index: 3,
+index: 4,
 ignoreTrivia: false);
         }
 
@@ -729,10 +729,6 @@ public Program()
     {
     }
 
-    public Program()
-    {
-    }
-
     public Program(string message) : base(message)
     {
     }
@@ -807,6 +803,66 @@ class B
     public B((int a, string b) x)
     {
     }
+}");
+        }
+
+        [WorkItem(6541, "https://github.com/dotnet/Roslyn/issues/6541")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        public async Task TestGenerateFromDerivedClass()
+        {
+            await TestInRegularAndScriptAsync(
+@"class Base
+{
+    public Base(string value)
+    {
+    }
+}
+
+class [||]Derived : Base
+{
+}",
+@"class Base
+{
+    public Base(string value)
+    {
+    }
+}
+
+class Derived : Base
+{
+    public Derived(string value) : base(value)
+    {
+    }
+}");
+        }
+
+        [WorkItem(6541, "https://github.com/dotnet/Roslyn/issues/6541")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        public async Task TestGenerateFromDerivedClass2()
+        {
+            await TestInRegularAndScriptAsync(
+@"class Base
+{
+    public Base(int a, string value = null)
+    {
+    }
+}
+
+class [||]Derived : Base
+{
+}",
+@"class Base
+{
+    public Base(int a, string value = null)
+    {
+    }
+}
+
+class Derived : Base
+{
+    public Derived(int a, string value = null) : base(a, value)
+    {
+    }
 }");
         }
     }

From 9e95f3c670da3a913c137a4e03aa962885608e5a Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 01:07:42 -0700
Subject: [PATCH 185/284] Add comment

---
 ...eConstructorFromMembersCodeRefactoringProvider.cs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/Features/Core/Portable/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs b/src/Features/Core/Portable/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs
index 17ef5f446f6fa..b8c8684b933d4 100644
--- a/src/Features/Core/Portable/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs
@@ -16,6 +16,18 @@
 
 namespace Microsoft.CodeAnalysis.GenerateConstructorFromMembers
 {
+    /// <summary>
+    /// This <see cref="CodeRefactoringProvider"/> is responsible for allowing a user to pick a 
+    /// set of members from a class or struct, and then generate a constructor for that takes in
+    /// matching parameters and assigns them to those members.  The members can be picked using 
+    /// a actual selection in the editor, or they can be picked using a picker control that will
+    /// then display all the viable members and allow the user to pick which ones they want to
+    /// use.
+    /// 
+    /// Importantly, this type is not responsible for generating constructors when the user types
+    /// something like "new MyType(x, y, z)", nor is it responsible for generating constructors
+    /// in a derived type that delegate to a base type.
+    /// </summary>
     [ExportCodeRefactoringProvider(LanguageNames.CSharp, LanguageNames.VisualBasic,
         Name = PredefinedCodeRefactoringProviderNames.GenerateConstructorFromMembers), Shared]
     [ExtensionOrder(Before = PredefinedCodeRefactoringProviderNames.GenerateEqualsAndGetHashCodeFromMembers)]

From 23fa44446c18012e84a91dcf2c8007fb38e05faa Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 01:10:35 -0700
Subject: [PATCH 186/284] Add comment

---
 ...erateDefaultConstructorsCodeRefactoringProvider.cs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs b/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
index 50efc3e4fdbba..7835bdeefefc9 100644
--- a/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
@@ -8,6 +8,17 @@
 
 namespace Microsoft.CodeAnalysis.GenerateDefaultConstructors
 {
+    /// <summary>
+    /// This <see cref="CodeRefactoringProvider"/> gives users a way to generate constructors for
+    /// a derived type that delegate to a base type.  For all accessibly constructors in the base
+    /// type, the user will be offered to create a constructor in the derived type with the same
+    /// signature if they don't already have one.  This way, a user can override a type and easily
+    /// create all the forwarding constructors.
+    /// 
+    /// Importantly, this type is not responsible for generating constructors when the user types
+    /// something like "new MyType(x, y, z)", nor is it responsible for generating constructors
+    /// for a type based on the fields/properties of that type.
+    /// </summary>
     [ExportCodeRefactoringProvider(LanguageNames.CSharp, LanguageNames.VisualBasic,
         Name = PredefinedCodeRefactoringProviderNames.GenerateDefaultConstructors), Shared]
     internal class GenerateDefaultConstructorsCodeRefactoringProvider : CodeRefactoringProvider

From cddbd90f7ff9459420e422c9ad26699c88ccba3c Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 01:14:40 -0700
Subject: [PATCH 187/284] Add comments

---
 .../GenerateConstructorCodeFixProvider.cs            | 12 ++++++++++++
 ...eConstructorFromMembersCodeRefactoringProvider.cs |  2 +-
 ...rateDefaultConstructorsCodeRefactoringProvider.cs |  3 ++-
 3 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/src/Features/CSharp/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.cs b/src/Features/CSharp/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.cs
index cb9c038cbe578..c626229ace175 100644
--- a/src/Features/CSharp/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.cs
@@ -29,6 +29,18 @@ internal static class GenerateConstructorDiagnosticIds
             ImmutableArray.Create(CS1729);
     }
 
+    /// <summary>
+    /// This <see cref="CodeFixProvider"/> gives users a way to generate constructors for an existing
+    /// type when a user tries to 'new' up an instance of that type with a set of parameter that does
+    /// not match any existing constructor.  i.e. it is the equivalent of 'Generate-Method' but for
+    /// constructors.  Parameters for the constructor will be picked in a manner similar to Generate-
+    /// Method.  However, this type will also attempt to hook up those parameters to existing fields
+    /// and properties, or pass them to a this/base constructor if available.
+    /// 
+    /// Importantly, this type is not responsible for generating constructors for a type based on 
+    /// the user selecting some fields/properties of that type.  Nor is it responsible for generating
+    /// derived class constructors for all unmatched base class constructors in a type hierarchy.
+    /// </summary>
     [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.GenerateConstructor), Shared]
     [ExtensionOrder(After = PredefinedCodeFixProviderNames.FullyQualify)]
     internal class GenerateConstructorCodeFixProvider : AbstractGenerateMemberCodeFixProvider
diff --git a/src/Features/Core/Portable/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs b/src/Features/Core/Portable/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs
index b8c8684b933d4..3348e6112d558 100644
--- a/src/Features/Core/Portable/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/GenerateConstructorFromMembers/GenerateConstructorFromMembersCodeRefactoringProvider.cs
@@ -26,7 +26,7 @@ namespace Microsoft.CodeAnalysis.GenerateConstructorFromMembers
     /// 
     /// Importantly, this type is not responsible for generating constructors when the user types
     /// something like "new MyType(x, y, z)", nor is it responsible for generating constructors
-    /// in a derived type that delegate to a base type.
+    /// in a derived type that delegate to a base type. Both of those are handled by other services.
     /// </summary>
     [ExportCodeRefactoringProvider(LanguageNames.CSharp, LanguageNames.VisualBasic,
         Name = PredefinedCodeRefactoringProviderNames.GenerateConstructorFromMembers), Shared]
diff --git a/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs b/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
index 7835bdeefefc9..97da2bd720204 100644
--- a/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeRefactoringProvider.cs
@@ -17,7 +17,8 @@ namespace Microsoft.CodeAnalysis.GenerateDefaultConstructors
     /// 
     /// Importantly, this type is not responsible for generating constructors when the user types
     /// something like "new MyType(x, y, z)", nor is it responsible for generating constructors
-    /// for a type based on the fields/properties of that type.
+    /// for a type based on the fields/properties of that type. Both of those are handled by other 
+    /// services.
     /// </summary>
     [ExportCodeRefactoringProvider(LanguageNames.CSharp, LanguageNames.VisualBasic,
         Name = PredefinedCodeRefactoringProviderNames.GenerateDefaultConstructors), Shared]

From 9781c815ca88ce24d52591be328931a6247a3d76 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 01:24:17 -0700
Subject: [PATCH 188/284] Simplify code.

---
 .../AbstractGenerateDefaultConstructorsService.State.cs        | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs
index 060d71848857a..e6528c08314b4 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs
@@ -46,8 +46,7 @@ private bool TryInitialize(
                 TextSpan textSpan,
                 CancellationToken cancellationToken)
             {
-                if (!service.TryInitializeState(document, textSpan, cancellationToken, 
-                        out var classOrStructType))
+                if (!service.TryInitializeState(document, textSpan, cancellationToken, out var classOrStructType))
                 {
                     return false;
                 }

From 9437cf870fc43f7d2713dc3484daf363b4eaa3d2 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 01:24:33 -0700
Subject: [PATCH 189/284] Remove unused usings.

---
 .../AbstractGenerateDefaultConstructorsService.State.cs        | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs
index e6528c08314b4..ca76eae576bd5 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs
@@ -1,11 +1,8 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System;
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
-using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.Utilities;

From 05fc4059a8866d750cf8add436f3eb9b03daaabd Mon Sep 17 00:00:00 2001
From: Alireza Habibi <habibi.alireza@outlook.com>
Date: Sun, 14 May 2017 19:19:41 +0430
Subject: [PATCH 190/284] Fix bug when caret is at the end of an argument

---
 .../UseNamedArgumentsTests.cs                 | 30 +++++++++++++++++
 .../UseNamedArgumentsTests.vb                 | 32 +++++++++++++++++++
 ...seNamedArgumentsCodeRefactoringProvider.cs |  8 ++++-
 3 files changed, 69 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/CSharpTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.cs
index ada21f218ece9..229e78d452d65 100644
--- a/src/EditorFeatures/CSharpTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.cs
+++ b/src/EditorFeatures/CSharpTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.cs
@@ -326,6 +326,36 @@ class C
 {
     void M(Action arg1, int arg2) 
         => M([|1 + 2|], 3);
+}");
+        }
+
+        [WorkItem(19175, "https://github.com/dotnet/roslyn/issues/19175")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseNamedArguments)]
+        public async Task TestCaretPositionAtTheEnd1()
+        {
+            await TestInRegularAndScriptAsync(
+@"class C
+{
+    void M(int arg1) => M(arg1[||]);
+}",
+@"class C
+{
+    void M(int arg1) => M(arg1: arg1);
+}");
+        }
+
+        [WorkItem(19175, "https://github.com/dotnet/roslyn/issues/19175")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseNamedArguments)]
+        public async Task TestCaretPositionAtTheEnd2()
+        {
+            await TestInRegularAndScriptAsync(
+@"class C
+{
+    void M(int arg1, int arg2) => M(arg1[||], arg2);
+}",
+@"class C
+{
+    void M(int arg1, int arg2) => M(arg1: arg1, arg2: arg2);
 }");
         }
     }
diff --git a/src/EditorFeatures/VisualBasicTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.vb b/src/EditorFeatures/VisualBasicTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.vb
index fd2f4085764d3..08a4edadb2240 100644
--- a/src/EditorFeatures/VisualBasicTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.vb
@@ -258,6 +258,38 @@ Class C
     Inherits System.Attribute
     Public Sub New(arg As Integer)
     End Sub
+End Class")
+        End Function
+
+        <WorkItem(19175, "https://github.com/dotnet/roslyn/issues/19175")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseNamedArguments)>
+        Public Async Function TestCaretPositionAtTheEnd1() As Task
+            Await TestInRegularAndScriptAsync(
+"Class C
+    Sub M(arg1 As Integer)
+        M(arg1[||])
+    End Sub
+End Class",
+"Class C
+    Sub M(arg1 As Integer)
+        M(arg1:=arg1)
+    End Sub
+End Class")
+        End Function
+
+        <WorkItem(19175, "https://github.com/dotnet/roslyn/issues/19175")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseNamedArguments)>
+        Public Async Function TestCaretPositionAtTheEnd2() As Task
+            Await TestInRegularAndScriptAsync(
+"Class C
+    Sub M(arg1 As Integer, arg2 As Integer)
+        M(arg1[||], arg2)
+    End Sub
+End Class",
+"Class C
+    Sub M(arg1 As Integer, arg2 As Integer)
+        M(arg1:=arg1, arg2:=arg2)
+    End Sub
 End Class")
         End Function
     End Class
diff --git a/src/Features/Core/Portable/CodeRefactorings/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs b/src/Features/Core/Portable/CodeRefactorings/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs
index 0b4f586720271..e413f51593f6b 100644
--- a/src/Features/Core/Portable/CodeRefactorings/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/CodeRefactorings/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs
@@ -34,7 +34,13 @@ public async Task ComputeRefactoringsAsync(
                     return;
                 }
 
-                var argument = root.FindNode(context.Span).FirstAncestorOrSelf<TBaseArgumentSyntax>() as TArgumentSyntax;
+                var token = root.FindToken(context.Span.Start);
+                if (token.ValueText == ")" || token.ValueText == ",")
+                {
+                    token = token.GetPreviousToken();
+                }
+
+                var argument = root.FindNode(token.Span).FirstAncestorOrSelf<TBaseArgumentSyntax>() as TArgumentSyntax;
                 if (argument == null)
                 {
                     return;

From 220d21edd17163f058e7a416a2caa8aacaa6e338 Mon Sep 17 00:00:00 2001
From: Alireza Habibi <habibi.alireza@outlook.com>
Date: Sun, 14 May 2017 09:27:20 +0430
Subject: [PATCH 191/284] Fix bug when caret is at the end of a numeric literal

---
 .../ConvertNumericLiteralTests.cs                 | 15 +++++++++++++++
 .../ConvertNumericLiteralTests.vb                 | 12 ++++++++++++
 ...onvertNumericLiteralCodeRefactoringProvider.cs | 14 +++++---------
 3 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs
index a1045549a699f..ae27a69079097 100644
--- a/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs
+++ b/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs
@@ -121,5 +121,20 @@ void M()
     }
 }", index: (int)Refactoring.ChangeBase2, ignoreTrivia: false);
         }
+
+        [WorkItem(19369, "https://github.com/dotnet/roslyn/issues/19369")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertNumericLiteral)]
+        public async Task TestCaretPositionAtTheEnd()
+        {
+            await TestInRegularAndScriptAsync(
+@"class C
+{
+  int a = 42[||];
+}",
+@"class C
+{
+  int a = 0b101010;
+}", index: (int)Refactoring.ChangeBase1);
+        }
     }
 }
diff --git a/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb b/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb
index d3810bad590af..c51c551401cad 100644
--- a/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb
@@ -111,5 +111,17 @@ End Class",
     End Sub
 End Class", index:=Refactoring.ChangeBase2, ignoreTrivia:=False)
         End Function
+
+        <WorkItem(19369, "https://github.com/dotnet/roslyn/issues/19369")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertNumericLiteral)>
+        Public Async Function TestCaretPositionAtTheEnd() As Task
+            Await TestInRegularAndScriptAsync(
+"Class C
+    Dim a As Integer = 42[||]
+End Class",
+"Class C
+    Dim a As Integer = &B101010
+End Class", index:=Refactoring.ChangeBase1)
+        End Function
     End Class
 End Namespace
diff --git a/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs
index 51306e6df2871..7e6322a47b9c5 100644
--- a/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs
@@ -19,26 +19,22 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex
         {
             var document = context.Document;
             var cancellationToken = context.CancellationToken;
+            var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
             var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var numericToken = await root.SyntaxTree.GetTouchingTokenAsync(context.Span.Start,
+                token => syntaxFacts.IsNumericLiteralExpression(token.Parent), cancellationToken).ConfigureAwait(false);
 
-            var numericToken = root.FindToken(context.Span.Start);
-            if (numericToken.ContainsDiagnostics)
+            if (numericToken == default(SyntaxToken))
             {
                 return;
             }
 
-            if (!numericToken.Span.Contains(context.Span))
+            if (numericToken.ContainsDiagnostics)
             {
                 return;
             }
 
             var syntaxNode = numericToken.Parent;
-            var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
-            if (!syntaxFacts.IsNumericLiteralExpression(syntaxNode))
-            {
-                return;
-            }
-
             var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var symbol = semanticModel.GetTypeInfo(syntaxNode, cancellationToken).Type;
             if (symbol == null)

From 20079ae2c29ccbc30d598958c9e5cb2760c41617 Mon Sep 17 00:00:00 2001
From: Alireza Habibi <habibi.alireza@outlook.com>
Date: Sun, 14 May 2017 21:27:57 +0430
Subject: [PATCH 192/284] Add test for omitted arguments

---
 .../UseNamedArgumentsTests.vb                 | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/src/EditorFeatures/VisualBasicTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.vb b/src/EditorFeatures/VisualBasicTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.vb
index 08a4edadb2240..3ea58433b8a52 100644
--- a/src/EditorFeatures/VisualBasicTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.vb
@@ -290,6 +290,28 @@ End Class",
     Sub M(arg1 As Integer, arg2 As Integer)
         M(arg1:=arg1, arg2:=arg2)
     End Sub
+End Class")
+        End Function
+
+        <WorkItem(19175, "https://github.com/dotnet/roslyn/issues/19175")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseNamedArguments)>
+        Public Async Function TestCaretPositionAtTheEnd3() As Task
+            Await TestMissingInRegularAndScriptAsync(
+"Class C
+    Sub M(arg1 As Integer, optional arg2 As Integer=1, optional arg3 as Integer=1)
+        M(1,[||],3)
+    End Sub
+End Class")
+        End Function
+
+        <WorkItem(19175, "https://github.com/dotnet/roslyn/issues/19175")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseNamedArguments)>
+        Public Async Function TestCaretPositionAtTheEnd4() As Task
+            Await TestMissingInRegularAndScriptAsync(
+"Class C
+    Sub M(arg1 As Integer, optional arg2 As Integer=1, optional arg3 as Integer=1)
+        M(1[||],,3)
+    End Sub
 End Class")
         End Function
     End Class

From 7d1f983fa26b18c24ba8ee2405aafa0e3a9c0b28 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 13:59:58 -0700
Subject: [PATCH 193/284] Fix case that was causing us to not offer completion
 after a case-pattern-label in a switch.

---
 .../CSharpCompletionCommandHandlerTests.vb    | 25 +++++++++++++++++++
 .../ContextQuery/SyntaxTokenExtensions.cs     |  5 +++-
 2 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb
index 709175329f8a5..19b8b9f0cff47 100644
--- a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb
@@ -3311,6 +3311,31 @@ class C
                     New TextChange(New TextSpan(0, _caretPosition), newText))
                 Return Task.FromResult(change)
             End Function
+
+            <WorkItem(15348, "https://github.com/dotnet/roslyn/issues/15348")>
+            <WpfFact, Trait(Traits.Feature, Traits.Features.Completion)>
+            Public Async Function TestAfterCasePatternSwitchLabel() As Task
+                Using state = TestState.CreateCSharpTestState(
+                              <Document>
+class C
+{
+    void M()
+    {
+        object o = 1;
+        switch(o)
+        {
+            case int i:
+                $$
+                break;
+        }
+    }
+}
+                              </Document>)
+
+                    state.SendTypeChars("this")
+                    Await state.AssertSelectedCompletionItem(displayText:="this", isHardSelected:=True)
+                End Using
+            End Function
         End Class
     End Class
 End Namespace
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Extensions/ContextQuery/SyntaxTokenExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/ContextQuery/SyntaxTokenExtensions.cs
index e61a4d638d53a..0500e4255c8ce 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/ContextQuery/SyntaxTokenExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/ContextQuery/SyntaxTokenExtensions.cs
@@ -153,7 +153,10 @@ public static bool IsBeginningOfStatementContext(this SyntaxToken token)
 
             if (token.Kind() == SyntaxKind.ColonToken)
             {
-                if (token.Parent.IsKind(SyntaxKind.CaseSwitchLabel, SyntaxKind.DefaultSwitchLabel, SyntaxKind.LabeledStatement))
+                if (token.Parent.IsKind(SyntaxKind.CaseSwitchLabel,
+                                        SyntaxKind.DefaultSwitchLabel,
+                                        SyntaxKind.CasePatternSwitchLabel,
+                                        SyntaxKind.LabeledStatement))
                 {
                     return true;
                 }

From d987cfe8af2aad906adf8ac9b13c20f471b320fa Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 17:46:17 -0700
Subject: [PATCH 194/284] Wrap lines.

---
 .../Utilities/AbstractSpeculationAnalyzer.cs         | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Utilities/AbstractSpeculationAnalyzer.cs b/src/Workspaces/Core/Portable/Utilities/AbstractSpeculationAnalyzer.cs
index 9e87e346698d1..f45dd713e6e36 100644
--- a/src/Workspaces/Core/Portable/Utilities/AbstractSpeculationAnalyzer.cs
+++ b/src/Workspaces/Core/Portable/Utilities/AbstractSpeculationAnalyzer.cs
@@ -17,8 +17,16 @@ namespace Microsoft.CodeAnalysis.Shared.Utilities
     /// It uses the original tree's semantic model to create a speculative semantic model and verifies that
     /// the syntax replacement doesn't break the semantics of any parenting nodes of the original expression.
     /// </summary>
-    internal abstract class AbstractSpeculationAnalyzer<TSyntaxNode, TExpressionSyntax, TTypeSyntax, TAttributeSyntax,
-        TArgumentSyntax, TForEachStatementSyntax, TThrowStatementSyntax, TSemanticModel, TConversion>
+    internal abstract class AbstractSpeculationAnalyzer<
+            TSyntaxNode,
+            TExpressionSyntax,
+            TTypeSyntax,
+            TAttributeSyntax,
+            TArgumentSyntax,
+            TForEachStatementSyntax,
+            TThrowStatementSyntax,
+            TSemanticModel,
+            TConversion>
         where TSyntaxNode : SyntaxNode
         where TExpressionSyntax : TSyntaxNode
         where TTypeSyntax : TExpressionSyntax

From 93cbd4cfc936e8e94bfa8d56f9e65e68fe858f61 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 17:48:12 -0700
Subject: [PATCH 195/284] Wrap lines.

---
 .../CSharp/Portable/Utilities/SpeculationAnalyzer.cs | 11 +++++++++--
 .../Portable/Utilities/SpeculationAnalyzer.vb        | 12 ++++++++++--
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/Utilities/SpeculationAnalyzer.cs b/src/Workspaces/CSharp/Portable/Utilities/SpeculationAnalyzer.cs
index 7250844558613..e28f7f78702c9 100644
--- a/src/Workspaces/CSharp/Portable/Utilities/SpeculationAnalyzer.cs
+++ b/src/Workspaces/CSharp/Portable/Utilities/SpeculationAnalyzer.cs
@@ -23,8 +23,15 @@ namespace Microsoft.CodeAnalysis.CSharp.Utilities
     /// the syntax replacement doesn't break the semantics of any parenting nodes of the original expression.
     /// </summary>
     internal class SpeculationAnalyzer : AbstractSpeculationAnalyzer<
-        SyntaxNode, ExpressionSyntax, TypeSyntax, AttributeSyntax,
-        ArgumentSyntax, CommonForEachStatementSyntax, ThrowStatementSyntax, SemanticModel, Conversion>
+        SyntaxNode,
+        ExpressionSyntax,
+        TypeSyntax,
+        AttributeSyntax,
+        ArgumentSyntax,
+        CommonForEachStatementSyntax,
+        ThrowStatementSyntax,
+        SemanticModel,
+        Conversion>
     {
         /// <summary>
         /// Creates a semantic analyzer for speculative syntax replacement.
diff --git a/src/Workspaces/VisualBasic/Portable/Utilities/SpeculationAnalyzer.vb b/src/Workspaces/VisualBasic/Portable/Utilities/SpeculationAnalyzer.vb
index 5d0083e64dad1..3d50df719cd3c 100644
--- a/src/Workspaces/VisualBasic/Portable/Utilities/SpeculationAnalyzer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Utilities/SpeculationAnalyzer.vb
@@ -19,8 +19,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Utilities
     ''' the syntax replacement doesn't break the semantics of any parenting nodes of the original expression.
     ''' </summary>
     Friend Class SpeculationAnalyzer
-        Inherits AbstractSpeculationAnalyzer(Of SyntaxNode, ExpressionSyntax, TypeSyntax, AttributeSyntax,
-                                             ArgumentSyntax, ForEachStatementSyntax, ThrowStatementSyntax, SemanticModel, Conversion)
+        Inherits AbstractSpeculationAnalyzer(Of
+            SyntaxNode,
+            ExpressionSyntax,
+            TypeSyntax,
+            AttributeSyntax,
+            ArgumentSyntax,
+            ForEachStatementSyntax,
+            ThrowStatementSyntax,
+            SemanticModel,
+            Conversion)
 
         ''' <summary>
         ''' Creates a semantic analyzer for speculative syntax replacement.

From ea9eb484d9b4db312534d5860f487848ec1a6db8 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 17:51:18 -0700
Subject: [PATCH 196/284] Remove unnecessary type parameters.

---
 .../Portable/Utilities/SpeculationAnalyzer.cs |  2 -
 .../Utilities/AbstractSpeculationAnalyzer.cs  | 72 +++++++++----------
 .../Portable/Utilities/SpeculationAnalyzer.vb |  2 -
 3 files changed, 34 insertions(+), 42 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/Utilities/SpeculationAnalyzer.cs b/src/Workspaces/CSharp/Portable/Utilities/SpeculationAnalyzer.cs
index e28f7f78702c9..ee86325f83d5a 100644
--- a/src/Workspaces/CSharp/Portable/Utilities/SpeculationAnalyzer.cs
+++ b/src/Workspaces/CSharp/Portable/Utilities/SpeculationAnalyzer.cs
@@ -23,14 +23,12 @@ namespace Microsoft.CodeAnalysis.CSharp.Utilities
     /// the syntax replacement doesn't break the semantics of any parenting nodes of the original expression.
     /// </summary>
     internal class SpeculationAnalyzer : AbstractSpeculationAnalyzer<
-        SyntaxNode,
         ExpressionSyntax,
         TypeSyntax,
         AttributeSyntax,
         ArgumentSyntax,
         CommonForEachStatementSyntax,
         ThrowStatementSyntax,
-        SemanticModel,
         Conversion>
     {
         /// <summary>
diff --git a/src/Workspaces/Core/Portable/Utilities/AbstractSpeculationAnalyzer.cs b/src/Workspaces/Core/Portable/Utilities/AbstractSpeculationAnalyzer.cs
index f45dd713e6e36..7f71e5cd86c9c 100644
--- a/src/Workspaces/Core/Portable/Utilities/AbstractSpeculationAnalyzer.cs
+++ b/src/Workspaces/Core/Portable/Utilities/AbstractSpeculationAnalyzer.cs
@@ -18,37 +18,33 @@ namespace Microsoft.CodeAnalysis.Shared.Utilities
     /// the syntax replacement doesn't break the semantics of any parenting nodes of the original expression.
     /// </summary>
     internal abstract class AbstractSpeculationAnalyzer<
-            TSyntaxNode,
             TExpressionSyntax,
             TTypeSyntax,
             TAttributeSyntax,
             TArgumentSyntax,
             TForEachStatementSyntax,
             TThrowStatementSyntax,
-            TSemanticModel,
             TConversion>
-        where TSyntaxNode : SyntaxNode
-        where TExpressionSyntax : TSyntaxNode
+        where TExpressionSyntax : SyntaxNode
         where TTypeSyntax : TExpressionSyntax
-        where TAttributeSyntax : TSyntaxNode
-        where TArgumentSyntax : TSyntaxNode
-        where TForEachStatementSyntax : TSyntaxNode
-        where TThrowStatementSyntax : TSyntaxNode
-        where TSemanticModel : SemanticModel
+        where TAttributeSyntax : SyntaxNode
+        where TArgumentSyntax : SyntaxNode
+        where TForEachStatementSyntax : SyntaxNode
+        where TThrowStatementSyntax : SyntaxNode
         where TConversion : struct
     {
         private readonly TExpressionSyntax _expression;
         private readonly TExpressionSyntax _newExpressionForReplace;
-        private readonly TSemanticModel _semanticModel;
+        private readonly SemanticModel _semanticModel;
         private readonly CancellationToken _cancellationToken;
         private readonly bool _skipVerificationForReplacedNode;
         private readonly bool _failOnOverloadResolutionFailuresInOriginalCode;
         private readonly bool _isNewSemanticModelSpeculativeModel;
 
-        private TSyntaxNode _lazySemanticRootOfOriginalExpression;
+        private SyntaxNode _lazySemanticRootOfOriginalExpression;
         private TExpressionSyntax _lazyReplacedExpression;
-        private TSyntaxNode _lazySemanticRootOfReplacedExpression;
-        private TSemanticModel _lazySpeculativeSemanticModel;
+        private SyntaxNode _lazySemanticRootOfReplacedExpression;
+        private SemanticModel _lazySpeculativeSemanticModel;
 
         /// <summary>
         /// Creates a semantic analyzer for speculative syntax replacement.
@@ -68,7 +64,7 @@ internal abstract class AbstractSpeculationAnalyzer<
         public AbstractSpeculationAnalyzer(
             TExpressionSyntax expression,
             TExpressionSyntax newExpression,
-            TSemanticModel semanticModel,
+            SemanticModel semanticModel,
             CancellationToken cancellationToken,
             bool skipVerificationForReplacedNode = false,
             bool failOnOverloadResolutionFailuresInOriginalCode = false)
@@ -96,7 +92,7 @@ public AbstractSpeculationAnalyzer(
         /// field initializer, default parameter initializer or type syntax node.
         /// It serves as the root node for all semantic analysis for this syntax replacement.
         /// </summary>
-        public TSyntaxNode SemanticRootOfOriginalExpression
+        public SyntaxNode SemanticRootOfOriginalExpression
         {
             get
             {
@@ -113,7 +109,7 @@ public TSyntaxNode SemanticRootOfOriginalExpression
         /// <summary>
         /// Semantic model for the syntax tree corresponding to <see cref="OriginalExpression"/>
         /// </summary>
-        public TSemanticModel OriginalSemanticModel => _semanticModel;
+        public SemanticModel OriginalSemanticModel => _semanticModel;
 
         /// <summary>
         /// Node which replaces the <see cref="OriginalExpression"/>.
@@ -134,7 +130,7 @@ public TExpressionSyntax ReplacedExpression
         /// This node is used as the argument to the GetSpeculativeSemanticModel API and serves as the root node for all
         /// semantic analysis of the speculated tree.
         /// </summary>
-        public TSyntaxNode SemanticRootOfReplacedExpression
+        public SyntaxNode SemanticRootOfReplacedExpression
         {
             get
             {
@@ -146,7 +142,7 @@ public TSyntaxNode SemanticRootOfReplacedExpression
         /// <summary>
         /// Speculative semantic model used for analyzing the semantics of the new tree.
         /// </summary>
-        public TSemanticModel SpeculativeSemanticModel
+        public SemanticModel SpeculativeSemanticModel
         {
             get
             {
@@ -157,9 +153,9 @@ public TSemanticModel SpeculativeSemanticModel
 
         public CancellationToken CancellationToken => _cancellationToken;
 
-        protected abstract TSyntaxNode GetSemanticRootForSpeculation(TExpressionSyntax expression);
+        protected abstract SyntaxNode GetSemanticRootForSpeculation(TExpressionSyntax expression);
 
-        protected virtual TSyntaxNode GetSemanticRootOfReplacedExpression(TSyntaxNode semanticRootOfOriginalExpression, TExpressionSyntax annotatedReplacedExpression)
+        protected virtual SyntaxNode GetSemanticRootOfReplacedExpression(SyntaxNode semanticRootOfOriginalExpression, TExpressionSyntax annotatedReplacedExpression)
         {
             return semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);
         }
@@ -179,19 +175,19 @@ private void EnsureReplacedExpressionAndSemanticRoot()
         }
 
         [Conditional("DEBUG")]
-        protected abstract void ValidateSpeculativeSemanticModel(TSemanticModel speculativeSemanticModel, TSyntaxNode nodeToSpeculate);
+        protected abstract void ValidateSpeculativeSemanticModel(SemanticModel speculativeSemanticModel, SyntaxNode nodeToSpeculate);
 
         private void EnsureSpeculativeSemanticModel()
         {
             if (_lazySpeculativeSemanticModel == null)
             {
-                TSyntaxNode nodeToSpeculate = this.SemanticRootOfReplacedExpression;
+                SyntaxNode nodeToSpeculate = this.SemanticRootOfReplacedExpression;
                 _lazySpeculativeSemanticModel = CreateSpeculativeSemanticModel(this.SemanticRootOfOriginalExpression, nodeToSpeculate, _semanticModel);
                 ValidateSpeculativeSemanticModel(_lazySpeculativeSemanticModel, nodeToSpeculate);
             }
         }
 
-        protected abstract TSemanticModel CreateSpeculativeSemanticModel(TSyntaxNode originalNode, TSyntaxNode nodeToSpeculate, TSemanticModel semanticModel);
+        protected abstract SemanticModel CreateSpeculativeSemanticModel(SyntaxNode originalNode, SyntaxNode nodeToSpeculate, SemanticModel semanticModel);
 
         #region Semantic comparison helpers
 
@@ -262,7 +258,7 @@ private bool ImplicitConversionsAreCompatible(TExpressionSyntax originalExpressi
         protected abstract bool ConversionsAreCompatible(SemanticModel model1, TExpressionSyntax expression1, SemanticModel model2, TExpressionSyntax expression2);
         protected abstract bool ConversionsAreCompatible(TExpressionSyntax originalExpression, ITypeSymbol originalTargetType, TExpressionSyntax newExpression, ITypeSymbol newTargetType);
 
-        protected bool SymbolsAreCompatible(TSyntaxNode originalNode, TSyntaxNode newNode, bool requireNonNullSymbols = false)
+        protected bool SymbolsAreCompatible(SyntaxNode originalNode, SyntaxNode newNode, bool requireNonNullSymbols = false)
         {
             Debug.Assert(originalNode != null);
             Debug.Assert(this.SemanticRootOfOriginalExpression.DescendantNodesAndSelf().Contains(originalNode));
@@ -416,9 +412,9 @@ public bool ReplacementChangesSemantics()
                 skipVerificationForCurrentNode: _skipVerificationForReplacedNode);
         }
 
-        protected abstract bool IsParenthesizedExpression(TSyntaxNode node);
+        protected abstract bool IsParenthesizedExpression(SyntaxNode node);
 
-        protected bool ReplacementChangesSemantics(TSyntaxNode currentOriginalNode, TSyntaxNode currentReplacedNode, TSyntaxNode originalRoot, bool skipVerificationForCurrentNode)
+        protected bool ReplacementChangesSemantics(SyntaxNode currentOriginalNode, SyntaxNode currentReplacedNode, SyntaxNode originalRoot, bool skipVerificationForCurrentNode)
         {
             if (this.SpeculativeSemanticModel == null)
             {
@@ -426,7 +422,7 @@ protected bool ReplacementChangesSemantics(TSyntaxNode currentOriginalNode, TSyn
                 return true;
             }
 
-            TSyntaxNode previousOriginalNode = null, previousReplacedNode = null;
+            SyntaxNode previousOriginalNode = null, previousReplacedNode = null;
 
             while (true)
             {
@@ -443,8 +439,8 @@ protected bool ReplacementChangesSemantics(TSyntaxNode currentOriginalNode, TSyn
 
                 previousOriginalNode = currentOriginalNode;
                 previousReplacedNode = currentReplacedNode;
-                currentOriginalNode = (TSyntaxNode)currentOriginalNode.Parent;
-                currentReplacedNode = (TSyntaxNode)currentReplacedNode.Parent;
+                currentOriginalNode = (SyntaxNode)currentOriginalNode.Parent;
+                currentReplacedNode = (SyntaxNode)currentReplacedNode.Parent;
                 skipVerificationForCurrentNode = skipVerificationForCurrentNode && IsParenthesizedExpression(currentReplacedNode);
             }
 
@@ -466,9 +462,9 @@ public bool SymbolsForOriginalAndReplacedNodesAreCompatible()
             return SymbolsAreCompatible(this.OriginalExpression, this.ReplacedExpression, requireNonNullSymbols: true);
         }
 
-        protected abstract bool ReplacementChangesSemanticsForNodeLanguageSpecific(TSyntaxNode currentOriginalNode, TSyntaxNode currentReplacedNode, TSyntaxNode previousOriginalNode, TSyntaxNode previousReplacedNode);
+        protected abstract bool ReplacementChangesSemanticsForNodeLanguageSpecific(SyntaxNode currentOriginalNode, SyntaxNode currentReplacedNode, SyntaxNode previousOriginalNode, SyntaxNode previousReplacedNode);
 
-        private bool ReplacementChangesSemanticsForNode(TSyntaxNode currentOriginalNode, TSyntaxNode currentReplacedNode, TSyntaxNode previousOriginalNode, TSyntaxNode previousReplacedNode)
+        private bool ReplacementChangesSemanticsForNode(SyntaxNode currentOriginalNode, SyntaxNode currentReplacedNode, SyntaxNode previousOriginalNode, SyntaxNode previousReplacedNode)
         {
             Debug.Assert(previousOriginalNode == null || previousOriginalNode.Parent == currentOriginalNode);
             Debug.Assert(previousReplacedNode == null || previousReplacedNode.Parent == currentReplacedNode);
@@ -532,7 +528,7 @@ private bool ReplacementBreaksAttribute(TAttributeSyntax attribute, TAttributeSy
 
         protected abstract TExpressionSyntax GetForEachStatementExpression(TForEachStatementSyntax forEachStatement);
 
-        protected abstract bool IsForEachTypeInferred(TForEachStatementSyntax forEachStatement, TSemanticModel semanticModel);
+        protected abstract bool IsForEachTypeInferred(TForEachStatementSyntax forEachStatement, SemanticModel semanticModel);
 
         private bool ReplacementBreaksForEachStatement(TForEachStatementSyntax forEachStatement, TForEachStatementSyntax newForEachStatement)
         {
@@ -645,7 +641,7 @@ private bool ReplacementBreaksTypeResolution(TTypeSyntax type, TTypeSyntax newTy
             return symbol != null && !SymbolsAreCompatible(symbol, newSymbol);
         }
 
-        protected abstract bool IsInvocableExpression(TSyntaxNode node);
+        protected abstract bool IsInvocableExpression(SyntaxNode node);
 
         private static bool IsDelegateInvoke(ISymbol symbol)
         {
@@ -758,7 +754,7 @@ private bool IsCompatibleInterfaceMemberImplementation(
             ISymbol newSymbol,
             TExpressionSyntax originalInvocationExpression,
             TExpressionSyntax newInvocationExpression,
-            TSemanticModel speculativeSemanticModel)
+            SemanticModel speculativeSemanticModel)
         {
             // If this is an interface member, we have to be careful. In general,
             // we have to treat an interface member as incompatible with the new member
@@ -863,7 +859,7 @@ private static bool IsEffectivelySealedClass(ITypeSymbol type)
             return false;
         }
 
-        private bool IsReceiverNonUniquePossibleValueTypeParam(TExpressionSyntax invocation, TSemanticModel semanticModel)
+        private bool IsReceiverNonUniquePossibleValueTypeParam(TExpressionSyntax invocation, SemanticModel semanticModel)
         {
             var receiver = GetReceiver(invocation);
             if (receiver != null)
@@ -881,7 +877,7 @@ private bool IsReceiverNonUniquePossibleValueTypeParam(TExpressionSyntax invocat
         // Returns true if the given receiver expression for an invocation represents a unique copy of the underlying object
         // that is not referenced by any other variable.
         // For example, if the receiver expression is an invocation, object-creation, element-access or member-access expression.
-        private static bool IsReceiverUniqueInstance(TExpressionSyntax receiver, TSemanticModel semanticModel)
+        private static bool IsReceiverUniqueInstance(TExpressionSyntax receiver, SemanticModel semanticModel)
         {
             var receiverSymbol = semanticModel.GetSymbolInfo(receiver).Symbol;
 
@@ -1065,7 +1061,7 @@ protected void GetConversions(
             }
         }
 
-        protected abstract TConversion ClassifyConversion(TSemanticModel model, TExpressionSyntax expression, ITypeSymbol targetType);
-        protected abstract TConversion ClassifyConversion(TSemanticModel model, ITypeSymbol originalType, ITypeSymbol targetType);
+        protected abstract TConversion ClassifyConversion(SemanticModel model, TExpressionSyntax expression, ITypeSymbol targetType);
+        protected abstract TConversion ClassifyConversion(SemanticModel model, ITypeSymbol originalType, ITypeSymbol targetType);
     }
 }
\ No newline at end of file
diff --git a/src/Workspaces/VisualBasic/Portable/Utilities/SpeculationAnalyzer.vb b/src/Workspaces/VisualBasic/Portable/Utilities/SpeculationAnalyzer.vb
index 3d50df719cd3c..a125296db1cdb 100644
--- a/src/Workspaces/VisualBasic/Portable/Utilities/SpeculationAnalyzer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Utilities/SpeculationAnalyzer.vb
@@ -20,14 +20,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Utilities
     ''' </summary>
     Friend Class SpeculationAnalyzer
         Inherits AbstractSpeculationAnalyzer(Of
-            SyntaxNode,
             ExpressionSyntax,
             TypeSyntax,
             AttributeSyntax,
             ArgumentSyntax,
             ForEachStatementSyntax,
             ThrowStatementSyntax,
-            SemanticModel,
             Conversion)
 
         ''' <summary>

From 4a4fedd57372717e9c2b2287a48ba06ed6dd40cb Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 18:30:53 -0700
Subject: [PATCH 197/284] Add new feature to suggest using 'default' instead of
 'default(T)' when possible.

---
 .../CSharp/Portable/CSharpFeatures.csproj     |  2 +
 .../CSharpUseDefaultLiteralCodeFixProvider.cs | 67 ++++++++++++++
 ...harpUseDefaultLiteralDiagnosticAnalyzer.cs | 88 +++++++++++++++++++
 .../Diagnostics/Analyzers/IDEDiagnosticIds.cs |  2 +
 .../Portable/FeaturesResources.Designer.cs    | 11 ++-
 .../Core/Portable/FeaturesResources.resx      |  3 +
 .../CodeStyle/CSharpCodeStyleOptions.cs       |  7 ++
 7 files changed, 179 insertions(+), 1 deletion(-)
 create mode 100644 src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
 create mode 100644 src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs

diff --git a/src/Features/CSharp/Portable/CSharpFeatures.csproj b/src/Features/CSharp/Portable/CSharpFeatures.csproj
index 5a98016cdb2c5..7b94fcf958c1a 100644
--- a/src/Features/CSharp/Portable/CSharpFeatures.csproj
+++ b/src/Features/CSharp/Portable/CSharpFeatures.csproj
@@ -95,6 +95,7 @@
     <Compile Include="UpgradeProject\CSharpUpgradeProjectCodeFixProvider.cs" />
     <Compile Include="UseCoalesceExpression\CSharpUseCoalesceExpressionForNullableDiagnosticAnalyzer.cs" />
     <Compile Include="UseCoalesceExpression\CSharpUseCoalesceExpressionDiagnosticAnalyzer.cs" />
+    <Compile Include="UseDefaultLiteral\CSharpUseDefaultLiteralCodeFixProvider.cs" />
     <Compile Include="UseExpressionBody\Helpers\UseExpressionBodyHelper.cs" />
     <Compile Include="UseExpressionBody\UseExpressionBodyCodeRefactoringProvider.cs" />
     <Compile Include="UseExpressionBody\UseExpressionBodyDiagnosticAnalyzer.cs" />
@@ -109,6 +110,7 @@
     <Compile Include="AddBraces\CSharpAddBracesDiagnosticAnalyzer.cs" />
     <Compile Include="UseCollectionInitializer\CSharpUseCollectionInitializerCodeFixProvider.cs" />
     <Compile Include="UseCollectionInitializer\CSharpUseCollectionInitializerDiagnosticAnalyzer.cs" />
+    <Compile Include="UseDefaultLiteral\CSharpUseDefaultLiteralDiagnosticAnalyzer.cs" />
     <Compile Include="UseNullPropagation\CSharpUseNullPropagationCodeFixProvider.cs" />
     <Compile Include="UseNullPropagation\CSharpUseNullPropagationDiagnosticAnalyzer.cs" />
     <Compile Include="UseObjectInitializer\UseInitializerHelpers.cs" />
diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
new file mode 100644
index 0000000000000..5b8fa1ce27386
--- /dev/null
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Immutable;
+using System.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.UseDefaultLiteral
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
+    internal partial class CSharpUseDefaultLiteralCodeFixProvider : SyntaxEditorBasedCodeFixProvider
+    {
+        public override ImmutableArray<string> FixableDiagnosticIds { get; }
+            = ImmutableArray.Create(IDEDiagnosticIds.UseDefaultLiteralDiagnosticId);
+
+        public override Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            context.RegisterCodeFix(new MyCodeAction(
+                c => FixAsync(context.Document, context.Diagnostics.First(), c)),
+                context.Diagnostics);
+            return SpecializedTasks.EmptyTask;
+        }
+
+        protected override Task FixAllAsync(
+            Document document, ImmutableArray<Diagnostic> diagnostics,
+            SyntaxEditor editor, CancellationToken cancellationToken)
+        {
+            foreach (var diagnostic in diagnostics)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                AddEdits(editor, diagnostic, cancellationToken);
+            }
+
+            return SpecializedTasks.EmptyTask;
+        }
+
+        private void AddEdits(
+            SyntaxEditor editor,
+            Diagnostic diagnostic,
+            CancellationToken cancellationToken)
+        {
+            var defaultExpression = (DefaultExpressionSyntax)diagnostic.Location.FindNode(
+                getInnermostNodeForTie: true, cancellationToken: cancellationToken);
+
+            var replacement = SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
+                                           .WithTriviaFrom(defaultExpression);
+            editor.ReplaceNode(defaultExpression, replacement);
+        }
+
+        private class MyCodeAction : CodeAction.DocumentChangeAction
+        {
+            public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
+                : base(FeaturesResources.Use_default_literal, createChangedDocument)
+            {
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
new file mode 100644
index 0000000000000..6b89374f71790
--- /dev/null
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Text;
+using System.Threading;
+using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp.Utilities;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.CSharp.UseDefaultLiteral
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    internal class CSharpUseDefaultLiteralDiagnosticAnalyzer : AbstractCodeStyleDiagnosticAnalyzer
+    {
+        private static readonly LiteralExpressionSyntax s_defaultLiteralExpression = SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression);
+
+        public CSharpUseDefaultLiteralDiagnosticAnalyzer() 
+            : base(IDEDiagnosticIds.UseDefaultLiteralDiagnosticId,
+                   new LocalizableResourceString(
+                       nameof(FeaturesResources.Use_default_literal), FeaturesResources.ResourceManager, typeof(FeaturesResources)))
+        {
+        }
+
+        public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
+            => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
+
+        public override bool OpenFileOnly(Workspace workspace)
+            => false;
+
+        protected override void InitializeWorker(AnalysisContext context)
+            => context.RegisterSyntaxNodeAction(AnalyzeSyntax, SyntaxKind.DefaultExpression);
+
+        private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
+        {
+            var cancellationToken = context.CancellationToken;
+
+            var syntaxTree = context.Node.SyntaxTree;
+            var parseOptions = (CSharpParseOptions)syntaxTree.Options;
+            if (parseOptions.LanguageVersion < LanguageVersion.CSharp7_1)
+            {
+                return;
+            }
+
+            var options = context.Options;
+            var optionSet = options.GetDocumentOptionSetAsync(syntaxTree, cancellationToken).GetAwaiter().GetResult();
+            if (optionSet == null)
+            {
+                return;
+            }
+
+            var codeStyleOption = optionSet.GetOption(CSharpCodeStyleOptions.PreferSimpleDefault);
+            if (!codeStyleOption.Value)
+            {
+                return;
+            }
+
+            var defaultExpression = (DefaultExpressionSyntax)context.Node;
+            if (!CanUseDefaultLiteral(defaultExpression, context.SemanticModel, cancellationToken))
+            {
+                return;
+            }
+
+            var fadeSpan = TextSpan.FromBounds(defaultExpression.OpenParenToken.SpanStart, defaultExpression.CloseParenToken.Span.End);
+
+            context.ReportDiagnostic(Diagnostic.Create(GetDescriptorWithSeverity(codeStyleOption.Notification.Value), defaultExpression.GetLocation()));
+            context.ReportDiagnostic(Diagnostic.Create(UnnecessaryWithoutSuggestionDescriptor, syntaxTree.GetLocation(fadeSpan)));
+        }
+
+        private bool CanUseDefaultLiteral(
+            DefaultExpressionSyntax defaultExpression,
+            SemanticModel semanticModel, 
+            CancellationToken cancellationToken)
+        {
+            var speculationAnalyzer = new SpeculationAnalyzer(
+                defaultExpression, s_defaultLiteralExpression, semanticModel,
+                cancellationToken,
+                skipVerificationForReplacedNode: true,
+                failOnOverloadResolutionFailuresInOriginalCode: true);
+
+            return !speculationAnalyzer.ReplacementChangesSemantics();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Features/Core/Portable/Diagnostics/Analyzers/IDEDiagnosticIds.cs b/src/Features/Core/Portable/Diagnostics/Analyzers/IDEDiagnosticIds.cs
index ee9474754a7b0..0af7854797e4b 100644
--- a/src/Features/Core/Portable/Diagnostics/Analyzers/IDEDiagnosticIds.cs
+++ b/src/Features/Core/Portable/Diagnostics/Analyzers/IDEDiagnosticIds.cs
@@ -44,6 +44,8 @@ internal static class IDEDiagnosticIds
 
         public const string UseExplicitTupleNameDiagnosticId = "IDE0033";
 
+        public const string UseDefaultLiteralDiagnosticId = "IDE0034";
+
         // Analyzer error Ids
         public const string AnalyzerChangedId = "IDE1001";
         public const string AnalyzerDependencyConflictId = "IDE1002";
diff --git a/src/Features/Core/Portable/FeaturesResources.Designer.cs b/src/Features/Core/Portable/FeaturesResources.Designer.cs
index 59d0e5cd0edbe..5b136db7f1f69 100644
--- a/src/Features/Core/Portable/FeaturesResources.Designer.cs
+++ b/src/Features/Core/Portable/FeaturesResources.Designer.cs
@@ -20,7 +20,7 @@ namespace Microsoft.CodeAnalysis {
     // class via a tool like ResGen or Visual Studio.
     // To add or remove a member, edit your .ResX file then rerun ResGen
     // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
     internal class FeaturesResources {
@@ -3280,6 +3280,15 @@ internal static string Use_coalesce_expression {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Use &apos;default&apos; literal.
+        /// </summary>
+        internal static string Use_default_literal {
+            get {
+                return ResourceManager.GetString("Use_default_literal", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Use explicitly provided tuple name.
         /// </summary>
diff --git a/src/Features/Core/Portable/FeaturesResources.resx b/src/Features/Core/Portable/FeaturesResources.resx
index 82215aa08b814..0498a68122edb 100644
--- a/src/Features/Core/Portable/FeaturesResources.resx
+++ b/src/Features/Core/Portable/FeaturesResources.resx
@@ -1241,4 +1241,7 @@ This version used in: {2}</value>
   <data name="Implement_0" xml:space="preserve">
     <value>Implement {0}</value>
   </data>
+  <data name="Use_default_literal" xml:space="preserve">
+    <value>Use 'default' literal</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/CodeStyle/CSharpCodeStyleOptions.cs b/src/Workspaces/CSharp/Portable/CodeStyle/CSharpCodeStyleOptions.cs
index 60da61813d77c..729e40ce1eec3 100644
--- a/src/Workspaces/CSharp/Portable/CodeStyle/CSharpCodeStyleOptions.cs
+++ b/src/Workspaces/CSharp/Portable/CodeStyle/CSharpCodeStyleOptions.cs
@@ -134,6 +134,12 @@ public static CodeStyleOption<ExpressionBodyPreference> ParseExpressionBodyPrefe
                 EditorConfigStorageLocation.ForBoolCodeStyleOption("csharp_prefer_braces"),
                 new RoamingProfileStorageLocation($"TextEditor.CSharp.Specific.{nameof(PreferBraces)}")});
 
+        public static readonly Option<CodeStyleOption<bool>> PreferSimpleDefault = new Option<CodeStyleOption<bool>>(
+            nameof(CodeStyleOptions), nameof(PreferSimpleDefault), defaultValue: CodeStyleOptions.TrueWithSuggestionEnforcement,
+            storageLocations: new OptionStorageLocation[] {
+                EditorConfigStorageLocation.ForBoolCodeStyleOption("csharp_prefer_simple_default"),
+                new RoamingProfileStorageLocation($"TextEditor.CSharp.Specific.{nameof(PreferSimpleDefault)}")});
+
         public static IEnumerable<Option<CodeStyleOption<bool>>> GetCodeStyleOptions()
         {
             yield return UseImplicitTypeForIntrinsicTypes;
@@ -143,6 +149,7 @@ public static IEnumerable<Option<CodeStyleOption<bool>>> GetCodeStyleOptions()
             yield return PreferPatternMatchingOverAsWithNullCheck;
             yield return PreferPatternMatchingOverIsWithCastCheck;
             yield return PreferBraces;
+            yield return PreferSimpleDefault;
         }
 
         public static IEnumerable<Option<CodeStyleOption<ExpressionBodyPreference>>> GetExpressionBodyOptions()

From 068e0a7eafba83fb8cd4f492b971616b2da3f3ca Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 18:48:21 -0700
Subject: [PATCH 198/284] Add user facing Code Style Option.

---
 .../CSharpUseDefaultLiteralDiagnosticAnalyzer.cs |  2 +-
 .../Impl/Options/Formatting/StyleViewModel.cs    | 16 ++++++++++++++++
 .../Core/Def/ServicesVSResources.Designer.cs     | 11 ++++++++++-
 .../Core/Def/ServicesVSResources.resx            |  7 +++++--
 .../Portable/CodeStyle/CSharpCodeStyleOptions.cs | 10 +++++-----
 5 files changed, 37 insertions(+), 9 deletions(-)

diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
index 6b89374f71790..2c4f7ba54c1fd 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
@@ -53,7 +53,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
                 return;
             }
 
-            var codeStyleOption = optionSet.GetOption(CSharpCodeStyleOptions.PreferSimpleDefault);
+            var codeStyleOption = optionSet.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral);
             if (!codeStyleOption.Value)
             {
                 return;
diff --git a/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs b/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
index 847ea817af208..f36f1a86e7998 100644
--- a/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
@@ -425,6 +425,21 @@ public Customer()
 //]
     }}
 }}
+";
+
+        private static readonly string s_preferDefaultLiteral = $@"
+using System.Threading;
+
+class Customer
+{{
+//[
+    // {ServicesVSResources.Prefer_colon}
+    void DoWork(CancellationToken cancellationToken = default) {{ }}
+
+    // {ServicesVSResources.Over_colon}
+    void DoWork(CancellationToken cancellationToken = default(CancellationToken)) {{ }}
+//]
+}}
 ";
 
         private static readonly string s_preferInlinedVariableDeclaration = $@"
@@ -693,6 +708,7 @@ internal StyleViewModel(OptionSet optionSet, IServiceProvider serviceProvider) :
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferPatternMatchingOverIsWithCastCheck, CSharpVSResources.Prefer_pattern_matching_over_is_with_cast_check, s_preferPatternMatchingOverIsWithCastCheck, s_preferPatternMatchingOverIsWithCastCheck, this, optionSet, expressionPreferencesGroupTitle));
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferPatternMatchingOverAsWithNullCheck, CSharpVSResources.Prefer_pattern_matching_over_as_with_null_check, s_preferPatternMatchingOverAsWithNullCheck, s_preferPatternMatchingOverAsWithNullCheck, this, optionSet, expressionPreferencesGroupTitle));
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CodeStyleOptions.PreferExplicitTupleNames, ServicesVSResources.Prefer_explicit_tuple_name, s_preferExplicitTupleName, s_preferExplicitTupleName, this, optionSet, expressionPreferencesGroupTitle));
+            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferDefaultLiteral, ServicesVSResources.Prefer_default_literal, s_preferDefaultLiteral, s_preferDefaultLiteral, this, optionSet, expressionPreferencesGroupTitle));
 
             AddExpressionBodyOptions(optionSet, expressionPreferencesGroupTitle);
 
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs b/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
index f151708ab124c..e5b777cdf34b8 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
@@ -19,7 +19,7 @@ namespace Microsoft.VisualStudio.LanguageServices {
     // class via a tool like ResGen or Visual Studio.
     // To add or remove a member, edit your .ResX file then rerun ResGen
     // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
     internal class ServicesVSResources {
@@ -1502,6 +1502,15 @@ internal static string Prefer_colon {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Prefer &apos;default&apos; literal.
+        /// </summary>
+        internal static string Prefer_default_literal {
+            get {
+                return ResourceManager.GetString("Prefer_default_literal", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Prefer explicit tuple name.
         /// </summary>
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index e23b643793526..0f2b08b225f0a 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -906,10 +906,13 @@ Additional information: {1}</value>
   <data name="prefer_throwing_properties" xml:space="preserve">
     <value>prefer throwing properties</value>
   </data>
-    <data name="When_generating_properties" xml:space="preserve">
+  <data name="When_generating_properties" xml:space="preserve">
     <value>When generating properties:</value>
-    </data>
+  </data>
   <data name="Options" xml:space="preserve">
     <value>Options</value>
   </data>
+  <data name="Prefer_default_literal" xml:space="preserve">
+    <value>Prefer 'default' literal</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/CodeStyle/CSharpCodeStyleOptions.cs b/src/Workspaces/CSharp/Portable/CodeStyle/CSharpCodeStyleOptions.cs
index 729e40ce1eec3..3348b55b2df2e 100644
--- a/src/Workspaces/CSharp/Portable/CodeStyle/CSharpCodeStyleOptions.cs
+++ b/src/Workspaces/CSharp/Portable/CodeStyle/CSharpCodeStyleOptions.cs
@@ -134,11 +134,11 @@ public static CodeStyleOption<ExpressionBodyPreference> ParseExpressionBodyPrefe
                 EditorConfigStorageLocation.ForBoolCodeStyleOption("csharp_prefer_braces"),
                 new RoamingProfileStorageLocation($"TextEditor.CSharp.Specific.{nameof(PreferBraces)}")});
 
-        public static readonly Option<CodeStyleOption<bool>> PreferSimpleDefault = new Option<CodeStyleOption<bool>>(
-            nameof(CodeStyleOptions), nameof(PreferSimpleDefault), defaultValue: CodeStyleOptions.TrueWithSuggestionEnforcement,
+        public static readonly Option<CodeStyleOption<bool>> PreferDefaultLiteral = new Option<CodeStyleOption<bool>>(
+            nameof(CodeStyleOptions), nameof(PreferDefaultLiteral), defaultValue: CodeStyleOptions.TrueWithSuggestionEnforcement,
             storageLocations: new OptionStorageLocation[] {
-                EditorConfigStorageLocation.ForBoolCodeStyleOption("csharp_prefer_simple_default"),
-                new RoamingProfileStorageLocation($"TextEditor.CSharp.Specific.{nameof(PreferSimpleDefault)}")});
+                EditorConfigStorageLocation.ForBoolCodeStyleOption("csharp_prefer_default_literal"),
+                new RoamingProfileStorageLocation($"TextEditor.CSharp.Specific.{nameof(PreferDefaultLiteral)}")});
 
         public static IEnumerable<Option<CodeStyleOption<bool>>> GetCodeStyleOptions()
         {
@@ -149,7 +149,7 @@ public static IEnumerable<Option<CodeStyleOption<bool>>> GetCodeStyleOptions()
             yield return PreferPatternMatchingOverAsWithNullCheck;
             yield return PreferPatternMatchingOverIsWithCastCheck;
             yield return PreferBraces;
-            yield return PreferSimpleDefault;
+            yield return PreferDefaultLiteral;
         }
 
         public static IEnumerable<Option<CodeStyleOption<ExpressionBodyPreference>>> GetExpressionBodyOptions()

From 58a811e586e9e905664597e5d0db5ad2a23aac30 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 19:47:31 -0700
Subject: [PATCH 199/284] Ensure fix-all doesn't break code.

---
 .../CSharpEditorServicesTest.csproj           |  1 +
 .../UseDefaultLiteralTests.cs                 | 18 +++++++
 .../CSharpUseDefaultLiteralCodeFixProvider.cs | 49 ++++++++++++++-----
 ...harpUseDefaultLiteralDiagnosticAnalyzer.cs | 22 +--------
 .../CSharp/Portable/CSharpWorkspace.csproj    |  1 +
 .../DefaultExpressionSyntaxExtensions.cs      | 27 ++++++++++
 6 files changed, 85 insertions(+), 33 deletions(-)
 create mode 100644 src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs
 create mode 100644 src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs

diff --git a/src/EditorFeatures/CSharpTest/CSharpEditorServicesTest.csproj b/src/EditorFeatures/CSharpTest/CSharpEditorServicesTest.csproj
index 24d00d4664012..8dc2d946cf2ad 100644
--- a/src/EditorFeatures/CSharpTest/CSharpEditorServicesTest.csproj
+++ b/src/EditorFeatures/CSharpTest/CSharpEditorServicesTest.csproj
@@ -396,6 +396,7 @@
     <Compile Include="UseCollectionInitializer\UseCollectionInitializerTests.cs" />
     <Compile Include="UseCoalesceExpression\UseCoalesceExpressionForNullableTests.cs" />
     <Compile Include="UseCoalesceExpression\UseCoalesceExpressionTests.cs" />
+    <Compile Include="UseDefaultLiteral\UseDefaultLiteralTests.cs" />
     <Compile Include="UseExplicitTupleName\UseExplicitTupleNameTests.cs" />
     <Compile Include="UseExpressionBody\Refactoring\UseExpressionBodyForConstructorsRefactoringTests.cs" />
     <Compile Include="UseExpressionBody\Refactoring\UseExpressionBodyForConversionOperatorsRefactoringTests.cs" />
diff --git a/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs b/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs
new file mode 100644
index 0000000000000..a1e0beefbc1d9
--- /dev/null
+++ b/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UseDefaultLiteral
+{
+    public class UseDefaultLiteralTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
+    {
+        internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
+            => (new CSharpUseThrowExpressionDiagnosticAnalyzer(), new UseThrowExpressionCodeFixProvider());
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseThrowExpression)]
+        public async Task WithoutBraces()
+        {
+    }
+}
diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
index 5b8fa1ce27386..24ff7aeb7893c 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Composition;
 using System.Linq;
@@ -8,6 +9,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
@@ -30,30 +32,51 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
             return SpecializedTasks.EmptyTask;
         }
 
-        protected override Task FixAllAsync(
+        protected override async Task FixAllAsync(
             Document document, ImmutableArray<Diagnostic> diagnostics,
             SyntaxEditor editor, CancellationToken cancellationToken)
         {
-            foreach (var diagnostic in diagnostics)
+            // Fix-All for this feature is somewhat complicated.  Each time we fix one case, it
+            // may make the next case unfixable.  For example:
+            //
+            //    'var v = x ? default(string) : default(string)'.
+
+            var workspace = document.Project.Solution.Workspace;
+            var originalRoot = editor.OriginalRoot;
+
+            var originalNodes = diagnostics.SelectAsArray(
+                d => (DefaultExpressionSyntax)originalRoot.FindNode(d.Location.SourceSpan, getInnermostNodeForTie: true));
+
+            // We're going to be continually editing this tree.  Track all the nodes we
+            // care about so we can find them across each edit.
+            document = document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodes));
+            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var currentRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+
+            foreach (var originalDefaultExpression in originalNodes)
             {
-                cancellationToken.ThrowIfCancellationRequested();
-                AddEdits(editor, diagnostic, cancellationToken);
+                var defaultExpression = currentRoot.GetCurrentNode(originalDefaultExpression);
+
+                if (defaultExpression.CanReplaceWithDefaultLiteral(semanticModel, cancellationToken))
+                {
+                    document = FixOne(document, currentRoot, defaultExpression);
+                    semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+                    currentRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+                }
             }
 
-            return SpecializedTasks.EmptyTask;
+            editor.ReplaceNode(originalRoot, currentRoot);
         }
 
-        private void AddEdits(
-            SyntaxEditor editor,
-            Diagnostic diagnostic,
-            CancellationToken cancellationToken)
+        private static Document FixOne(
+            Document document, SyntaxNode currentRoot, DefaultExpressionSyntax defaultExpression)
         {
-            var defaultExpression = (DefaultExpressionSyntax)diagnostic.Location.FindNode(
-                getInnermostNodeForTie: true, cancellationToken: cancellationToken);
-
             var replacement = SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
                                            .WithTriviaFrom(defaultExpression);
-            editor.ReplaceNode(defaultExpression, replacement);
+
+            var newRoot = currentRoot.ReplaceNode(defaultExpression, replacement);
+
+            return document.WithSyntaxRoot(newRoot);
         }
 
         private class MyCodeAction : CodeAction.DocumentChangeAction
diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
index 2c4f7ba54c1fd..644316141d4dd 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
@@ -1,12 +1,9 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Text;
 using System.Threading;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Utilities;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -17,7 +14,6 @@ namespace Microsoft.CodeAnalysis.CSharp.UseDefaultLiteral
     [DiagnosticAnalyzer(LanguageNames.CSharp)]
     internal class CSharpUseDefaultLiteralDiagnosticAnalyzer : AbstractCodeStyleDiagnosticAnalyzer
     {
-        private static readonly LiteralExpressionSyntax s_defaultLiteralExpression = SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression);
 
         public CSharpUseDefaultLiteralDiagnosticAnalyzer() 
             : base(IDEDiagnosticIds.UseDefaultLiteralDiagnosticId,
@@ -60,7 +56,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
             }
 
             var defaultExpression = (DefaultExpressionSyntax)context.Node;
-            if (!CanUseDefaultLiteral(defaultExpression, context.SemanticModel, cancellationToken))
+            if (!defaultExpression.CanReplaceWithDefaultLiteral(context.SemanticModel, cancellationToken))
             {
                 return;
             }
@@ -70,19 +66,5 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
             context.ReportDiagnostic(Diagnostic.Create(GetDescriptorWithSeverity(codeStyleOption.Notification.Value), defaultExpression.GetLocation()));
             context.ReportDiagnostic(Diagnostic.Create(UnnecessaryWithoutSuggestionDescriptor, syntaxTree.GetLocation(fadeSpan)));
         }
-
-        private bool CanUseDefaultLiteral(
-            DefaultExpressionSyntax defaultExpression,
-            SemanticModel semanticModel, 
-            CancellationToken cancellationToken)
-        {
-            var speculationAnalyzer = new SpeculationAnalyzer(
-                defaultExpression, s_defaultLiteralExpression, semanticModel,
-                cancellationToken,
-                skipVerificationForReplacedNode: true,
-                failOnOverloadResolutionFailuresInOriginalCode: true);
-
-            return !speculationAnalyzer.ReplacementChangesSemantics();
-        }
     }
 }
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/CSharpWorkspace.csproj b/src/Workspaces/CSharp/Portable/CSharpWorkspace.csproj
index 1edfa6cb05691..8320354f686e7 100644
--- a/src/Workspaces/CSharp/Portable/CSharpWorkspace.csproj
+++ b/src/Workspaces/CSharp/Portable/CSharpWorkspace.csproj
@@ -103,6 +103,7 @@
     <Compile Include="Extensions\ArrowExpressionClauseSyntaxExtensions.cs" />
     <Compile Include="Extensions\AssignmentExpressionSyntaxExtensions.cs" />
     <Compile Include="Extensions\BlockSyntaxExtensions.cs" />
+    <Compile Include="Extensions\DefaultExpressionSyntaxExtensions.cs" />
     <Compile Include="Extensions\SemanticModelExtensions.cs" />
     <Compile Include="Formatting\CSharpFormattingOptions.Parsers.cs" />
     <Compile Include="LanguageServices\CSharpCommandLineParserService.cs" />
diff --git a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
new file mode 100644
index 0000000000000..3d90f6d356f3e
--- /dev/null
+++ b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.Extensions
+{
+    internal static class DefaultExpressionSyntaxExtensions
+    {
+        private static readonly LiteralExpressionSyntax s_defaultLiteralExpression = SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression);
+
+        public static bool CanReplaceWithDefaultLiteral(
+            this DefaultExpressionSyntax defaultExpression,
+            SemanticModel semanticModel,
+            CancellationToken cancellationToken)
+        {
+            var speculationAnalyzer = new SpeculationAnalyzer(
+                defaultExpression, s_defaultLiteralExpression, semanticModel,
+                cancellationToken,
+                skipVerificationForReplacedNode: true,
+                failOnOverloadResolutionFailuresInOriginalCode: true);
+
+            return !speculationAnalyzer.ReplacementChangesSemantics();
+        }
+    }
+}

From dc8f7d60fba8f7afd438c3abe2a5758856319811 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 19:47:48 -0700
Subject: [PATCH 200/284] remove unused usings.

---
 .../UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
index 24ff7aeb7893c..4af924ba91385 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Composition;
 using System.Linq;
@@ -13,7 +12,6 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
-using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.UseDefaultLiteral

From 78ac09af362726a5e74c06d8817d2b5488dc0528 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 19:48:45 -0700
Subject: [PATCH 201/284] Only supported in C# 7.1 and later.

---
 .../Extensions/DefaultExpressionSyntaxExtensions.cs         | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
index 3d90f6d356f3e..221992eb62258 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
@@ -15,6 +15,12 @@ public static bool CanReplaceWithDefaultLiteral(
             SemanticModel semanticModel,
             CancellationToken cancellationToken)
         {
+            var options = (CSharpParseOptions)semanticModel.SyntaxTree.Options;
+            if (options.LanguageVersion < LanguageVersion.CSharp7_1)
+            {
+                return false;
+            }
+
             var speculationAnalyzer = new SpeculationAnalyzer(
                 defaultExpression, s_defaultLiteralExpression, semanticModel,
                 cancellationToken,

From c65efd1ccc014a4cc35fc13fe8104e459d08d8e9 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 20:25:04 -0700
Subject: [PATCH 202/284] Add tests.

---
 .../UseDefaultLiteralTests.cs                 | 226 +++++++++++++++++-
 src/EditorFeatures/TestUtilities/Traits.cs    |   1 +
 2 files changed, 219 insertions(+), 8 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs b/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs
index a1e0beefbc1d9..30008ce23fcc0 100644
--- a/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs
+++ b/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs
@@ -1,18 +1,228 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.UseDefaultLiteral;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
+using Roslyn.Test.Utilities;
+using Xunit;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UseDefaultLiteral
 {
     public class UseDefaultLiteralTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
     {
         internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
-            => (new CSharpUseThrowExpressionDiagnosticAnalyzer(), new UseThrowExpressionCodeFixProvider());
+            => (new CSharpUseDefaultLiteralDiagnosticAnalyzer(), new CSharpUseDefaultLiteralCodeFixProvider());
+
+        private static readonly CSharpParseOptions s_parseOptions = 
+            CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_1);
+
+        private static readonly TestParameters s_testParameters =
+            new TestParameters(parseOptions: s_parseOptions);
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestNotInCSharp7()
+        {
+            await TestMissingAsync(
+@"
+class C
+{
+    void Foo(string s = [||]default(string))
+    {
+    }
+}", parameters: new TestParameters(
+    parseOptions: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7)));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestInParameterList()
+        {
+            await TestAsync(
+@"
+class C
+{
+    void Foo(string s = [||]default(string))
+    {
+    }
+}",
+@"
+class C
+{
+    void Foo(string s = default)
+    {
+    }
+}", parseOptions: s_parseOptions);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestInLocalInitializer()
+        {
+            await TestAsync(
+@"
+class C
+{
+    void Foo()
+    {
+        string s = [||]default(string);
+    }
+}",
+@"
+class C
+{
+    void Foo()
+    {
+        string s = default;
+    }
+}", parseOptions: s_parseOptions);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestNotForVar()
+        {
+            await TestMissingAsync(
+@"
+class C
+{
+    void Foo()
+    {
+        var s = [||]default(string);
+    }
+}",  parameters: s_testParameters);
+        }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseThrowExpression)]
-        public async Task WithoutBraces()
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestInInvocationExpression()
         {
+            await TestAsync(
+@"
+class C
+{
+    void Foo()
+    {
+        Bar([||]default(string));
+    }
+
+    void Bar(string s) { }
+}",
+@"
+class C
+{
+    void Foo()
+    {
+        Bar(default);
+    }
+
+    void Bar(string s) { }
+}", parseOptions: s_parseOptions);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestNotWithMultipleOverloads()
+        {
+            await TestMissingAsync(
+@"
+class C
+{
+    void Foo()
+    {
+        Bar([||]default(string));
+    }
+
+    void Bar(string s) { }
+    void Bar(int i);
+}", parameters: s_testParameters);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestLeftSideOfTernary()
+        {
+            await TestAsync(
+@"
+class C
+{
+    void Foo(bool b)
+    {
+        var v = b ? [||]default(string) : default(string);
+    }
+}",
+@"
+class C
+{
+    void Foo(bool b)
+    {
+        var v = b ? default : default(string);
+    }
+}", parseOptions: s_parseOptions);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestRightSideOfTernary()
+        {
+            await TestAsync(
+@"
+class C
+{
+    void Foo(bool b)
+    {
+        var v = b ? default(string) : [||]default(string);
+    }
+}",
+@"
+class C
+{
+    void Foo(bool b)
+    {
+        var v = b ? default(string) : default;
+    }
+}", parseOptions: s_parseOptions);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestFixAll1()
+        {
+            await TestAsync(
+@"
+class C
+{
+    void Foo()
+    {
+        string s1 = {|FixAllInDocument:default|}(string);
+        string s2 = default(string);
+    }
+}",
+@"
+class C
+{
+    void Foo()
+    {
+        string s1 = default;
+        string s2 = default;
+    }
+}", parseOptions: s_parseOptions);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestFixAll2()
+        {
+            await TestAsync(
+@"
+class C
+{
+    void Foo(bool b)
+    {
+        string s1 = b ? {|FixAllInDocument:default|}(string) : defalut(string);
+    }
+}",
+@"
+class C
+{
+    void Foo(bool b)
+    {
+        string s1 = b ? default : defalut(string);
+    }
+}", parseOptions: s_parseOptions);
+        }
     }
-}
+}
\ No newline at end of file
diff --git a/src/EditorFeatures/TestUtilities/Traits.cs b/src/EditorFeatures/TestUtilities/Traits.cs
index 1d5d2ab974ed8..da4c5cab9b3be 100644
--- a/src/EditorFeatures/TestUtilities/Traits.cs
+++ b/src/EditorFeatures/TestUtilities/Traits.cs
@@ -96,6 +96,7 @@ public static class Features
             public const string CodeActionsUseAutoProperty = "CodeActions.UseAutoProperty";
             public const string CodeActionsUseCoalesceExpression = "CodeActions.UseCoalesceExpression";
             public const string CodeActionsUseCollectionInitializer = "CodeActions.UseCollectionInitializer";
+            public const string CodeActionsUseDefaultLiteral = "CodeActions.UseDefaultLiteral";
             public const string CodeActionsUseExpressionBody = "CodeActions.UseExpressionBody";
             public const string CodeActionsUseImplicitType = "CodeActions.UseImplicitType";
             public const string CodeActionsUseExplicitType = "CodeActions.UseExplicitType";

From 4d14d982494303d854efb42cd63462b0243fb933 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 21:50:28 -0700
Subject: [PATCH 203/284] Use 'default' when possible.

---
 .../ImplementInterfaceTests.cs                | 34 +++++++++++++++++++
 .../CodeGeneration/CSharpSyntaxGenerator.cs   |  6 ++--
 .../CodeGeneration/ExpressionGenerator.cs     |  7 ++--
 .../CodeGeneration/ParameterGenerator.cs      |  6 ++--
 .../DefaultExpressionSyntaxExtensions.cs      |  6 ----
 .../CSharpSimplificationService.cs            |  3 --
 ...CSharpReducer.AbstractReductionRewriter.cs |  5 ++-
 .../CSharpMiscellaneousReducer.Rewriter.cs    | 34 +++++++++++++++++++
 .../Reducers/CSharpMiscellaneousReducer.cs    |  1 +
 .../AbstractReducer.IExpressionRewriter.cs    |  2 +-
 .../AbstractSimplificationService.cs          |  4 +--
 ...lBasicReducer.AbstractReductionRewriter.vb |  5 ++-
 12 files changed, 87 insertions(+), 26 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
index 3453a4230e427..7b14ed0fdeca3 100644
--- a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
+++ b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
@@ -47,6 +47,8 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
                  SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithNoneEnforcement),
                  SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithNoneEnforcement));
 
+        private static readonly ParseOptions CSharp7_1 = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_1);
+
         internal async Task TestWithAllCodeStyleOptionsOffAsync(
             string initialMarkup, string expectedMarkup,
             int index = 0, bool ignoreTrivia = true,
@@ -6789,5 +6791,37 @@ class Class : IInterface
     ImplementTypeOptions.PropertyGenerationBehavior,
     ImplementTypePropertyGenerationBehavior.PreferAutoProperties)));
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestOptionalParameterWithDefaultLiteral()
+        {
+            await TestWithAllCodeStyleOptionsOffAsync(
+@"
+using System.Threading;
+
+interface IInterface
+{
+    void Method1(CancellationToken cancellationToken = default(CancellationToken));
+}
+
+class Class : [|IInterface|]
+{
+}",
+@"
+using System.Threading;
+
+interface IInterface
+{
+    void Method1(CancellationToken cancellationToken = default(CancellationToken));
+}
+
+class Class : IInterface
+{
+    public void Method1(CancellationToken cancellationToken = default)
+    {
+        throw new System.NotImplementedException();
+    }
+}", parseOptions: CSharp7_1);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
index 276ac06c8ff00..2acfb275bf7e9 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
@@ -3665,9 +3665,7 @@ internal override SyntaxToken NumericLiteralToken(string text, ulong value)
             => SyntaxFactory.Literal(text, value);
 
         public override SyntaxNode DefaultExpression(SyntaxNode type)
-        {
-            return SyntaxFactory.DefaultExpression((TypeSyntax)type);
-        }
+            => SyntaxFactory.DefaultExpression((TypeSyntax)type).WithAdditionalAnnotations(Simplifier.Annotation);
 
         public override SyntaxNode DefaultExpression(ITypeSymbol type)
         {
@@ -3701,7 +3699,7 @@ public override SyntaxNode DefaultExpression(ITypeSymbol type)
             }
 
             // Default to a "default(<typename>)" expression.
-            return SyntaxFactory.DefaultExpression(type.GenerateTypeSyntax());
+            return DefaultExpression(type.GenerateTypeSyntax());
         }
 
         private ExpressionSyntax Parenthesize(SyntaxNode expression)
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/ExpressionGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/ExpressionGenerator.cs
index fc3d844cf5822..2ca8e6c18f95a 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/ExpressionGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/ExpressionGenerator.cs
@@ -9,7 +9,6 @@
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Shared.Extensions;
-using Microsoft.CodeAnalysis.Shared.Utilities;
 using Microsoft.CodeAnalysis.Simplification;
 using Roslyn.Utilities;
 
@@ -46,9 +45,7 @@ internal static ExpressionSyntax GenerateExpression(
         }
 
         private static ExpressionSyntax GenerateNullLiteral()
-        {
-            return SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
-        }
+            => SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
 
         internal static ExpressionSyntax GenerateExpression(
             ITypeSymbol type,
@@ -97,7 +94,7 @@ internal static ExpressionSyntax GenerateNonEnumValueExpression(
 
             return type == null || type.IsReferenceType || type.IsPointerType() || type.IsNullable()
                 ? GenerateNullLiteral()
-                : SyntaxFactory.DefaultExpression(type.GenerateTypeSyntax());
+                : (ExpressionSyntax)CSharpSyntaxGenerator.Instance.DefaultExpression(type);
         }
 
         private static ExpressionSyntax GenerateBooleanLiteralExpression(bool val)
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/ParameterGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/ParameterGenerator.cs
index 27bb44afb61cf..9b792d4b70619 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/ParameterGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/ParameterGenerator.cs
@@ -53,12 +53,12 @@ public static BracketedParameterListSyntax GenerateBracketedParameterList(
                 parameters: SyntaxFactory.SeparatedList(parameters));
         }
 
-        internal static List<ParameterSyntax> GetParameters(
+        internal static ImmutableArray<ParameterSyntax> GetParameters(
             IEnumerable<IParameterSymbol> parameterDefinitions,
             bool isExplicit,
             CodeGenerationOptions options)
         {
-            var result = new List<ParameterSyntax>();
+            var result = ArrayBuilder<ParameterSyntax>.GetInstance();
             var seenOptional = false;
             var isFirstParam = true;
 
@@ -70,7 +70,7 @@ internal static List<ParameterSyntax> GetParameters(
                 isFirstParam = false;
             }
 
-            return result;
+            return result.ToImmutableAndFree();
         }
 
         internal static ParameterSyntax GetParameter(IParameterSymbol p, CodeGenerationOptions options, bool isExplicit, bool isFirstParam, bool seenOptional)
diff --git a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
index 221992eb62258..3d90f6d356f3e 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
@@ -15,12 +15,6 @@ public static bool CanReplaceWithDefaultLiteral(
             SemanticModel semanticModel,
             CancellationToken cancellationToken)
         {
-            var options = (CSharpParseOptions)semanticModel.SyntaxTree.Options;
-            if (options.LanguageVersion < LanguageVersion.CSharp7_1)
-            {
-                return false;
-            }
-
             var speculationAnalyzer = new SpeculationAnalyzer(
                 defaultExpression, s_defaultLiteralExpression, semanticModel,
                 cancellationToken,
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpSimplificationService.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpSimplificationService.cs
index 89c78c6fe5510..753402d01e18e 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpSimplificationService.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpSimplificationService.cs
@@ -4,16 +4,13 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Composition;
-using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Utilities;
-using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Simplification;
-using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.AbstractReductionRewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.AbstractReductionRewriter.cs
index 48bc70d426c05..86ddbd17a525f 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.AbstractReductionRewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.AbstractReductionRewriter.cs
@@ -18,6 +18,7 @@ protected abstract class AbstractReductionRewriter : CSharpSyntaxRewriter, IRedu
         {
             private readonly ObjectPool<IReductionRewriter> _pool;
 
+            protected ParseOptions ParseOptions { get; private set; }
             private OptionSet _optionSet;
             private CancellationToken _cancellationToken;
             private SemanticModel _semanticModel;
@@ -33,14 +34,16 @@ protected abstract class AbstractReductionRewriter : CSharpSyntaxRewriter, IRedu
             protected AbstractReductionRewriter(ObjectPool<IReductionRewriter> pool)
                 => _pool = pool;
 
-            public void Initialize(OptionSet optionSet, CancellationToken cancellationToken)
+            public void Initialize(ParseOptions parseOptions, OptionSet optionSet, CancellationToken cancellationToken)
             {
+                ParseOptions = parseOptions;
                 _optionSet = optionSet;
                 _cancellationToken = cancellationToken;
             }
 
             public void Dispose()
             {
+                ParseOptions = null;
                 _optionSet = null;
                 _cancellationToken = CancellationToken.None;
                 _processedParentNodes.Clear();
diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs
index c8a1d670ce039..efadfd8da46de 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs
@@ -1,6 +1,11 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
+using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Options;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
@@ -12,6 +17,7 @@ private class Rewriter : AbstractReductionRewriter
             public Rewriter(ObjectPool<IReductionRewriter> pool)
                 : base(pool)
             {
+                _simplifyDefaultExpression = SimplifyDefaultExpression;
             }
 
             public override SyntaxNode VisitParameter(ParameterSyntax node)
@@ -40,6 +46,34 @@ public override SyntaxNode VisitBlock(BlockSyntax node)
                     parentNode: node.Parent,
                     simplifier: s_simplifyBlock);
             }
+
+            private readonly Func<DefaultExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode> _simplifyDefaultExpression;
+
+            private SyntaxNode SimplifyDefaultExpression(
+                DefaultExpressionSyntax node,
+                SemanticModel semanticModel,
+                OptionSet optionSet,
+                CancellationToken cancellationToken)
+            {
+                if (optionSet.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Value &&
+                    node.CanReplaceWithDefaultLiteral(semanticModel, cancellationToken) &&
+                    ((CSharpParseOptions)ParseOptions).LanguageVersion >= LanguageVersion.CSharp7_1)
+                {
+                    return SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
+                                        .WithTriviaFrom(node);
+                }
+
+                return node;
+            }
+
+            public override SyntaxNode VisitDefaultExpression(DefaultExpressionSyntax node)
+            {
+                return SimplifyNode(
+                    node,
+                    newNode: base.VisitDefaultExpression(node),
+                    parentNode: node.Parent,
+                    simplifier: _simplifyDefaultExpression);
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
index 931a90684ed35..8a3dbffeaff18 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
@@ -100,6 +100,7 @@ private static SyntaxNode SimplifyParenthesizedLambdaExpression(
 
             return parenthesizedLambda;
         }
+
         private static readonly Func<BlockSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode> s_simplifyBlock = SimplifyBlock;
 
         private static SyntaxNode SimplifyBlock(
diff --git a/src/Workspaces/Core/Portable/Simplification/AbstractReducer.IExpressionRewriter.cs b/src/Workspaces/Core/Portable/Simplification/AbstractReducer.IExpressionRewriter.cs
index c3e57a10aa5d5..925467ccb5d26 100644
--- a/src/Workspaces/Core/Portable/Simplification/AbstractReducer.IExpressionRewriter.cs
+++ b/src/Workspaces/Core/Portable/Simplification/AbstractReducer.IExpressionRewriter.cs
@@ -10,7 +10,7 @@ internal abstract partial class AbstractReducer
     {
         internal interface IReductionRewriter : IDisposable
         {
-            void Initialize(OptionSet optionSet, CancellationToken cancellationToken);
+            void Initialize(ParseOptions parseOptions, OptionSet optionSet, CancellationToken cancellationToken);
 
             SyntaxNodeOrToken VisitNodeOrToken(SyntaxNodeOrToken nodeOrTokenToReduce, SemanticModel semanticModel, bool simplifyAllDescendants);
 
diff --git a/src/Workspaces/Core/Portable/Simplification/AbstractSimplificationService.cs b/src/Workspaces/Core/Portable/Simplification/AbstractSimplificationService.cs
index 96c5941cbbab3..a7bca7881b1c9 100644
--- a/src/Workspaces/Core/Portable/Simplification/AbstractSimplificationService.cs
+++ b/src/Workspaces/Core/Portable/Simplification/AbstractSimplificationService.cs
@@ -191,7 +191,7 @@ private Task ReduceAsync(
 
                         using (var rewriter = reducer.GetOrCreateRewriter())
                         {
-                            rewriter.Initialize(optionSet, cancellationToken);
+                            rewriter.Initialize(document.Project.ParseOptions, optionSet, cancellationToken);
 
                             do
                             {
@@ -228,7 +228,7 @@ private Task ReduceAsync(
                                         if (this.CanNodeBeSimplifiedWithoutSpeculation(nodeOrToken.AsNode()))
                                         {
                                             // Since this node cannot be speculated, we are replacing the Document with the changes and get a new SemanticModel
-                                            SyntaxAnnotation marker = new SyntaxAnnotation();
+                                            var marker = new SyntaxAnnotation();
                                             var newRoot = root.ReplaceNode(nodeOrToken.AsNode(), currentNode.WithAdditionalAnnotations(marker));
                                             var newDocument = document.WithSyntaxRoot(newRoot);
                                             semanticModelForReduce = await newDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
diff --git a/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/AbstractVisualBasicReducer.AbstractReductionRewriter.vb b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/AbstractVisualBasicReducer.AbstractReductionRewriter.vb
index b3495c1852870..a7245272d67a2 100644
--- a/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/AbstractVisualBasicReducer.AbstractReductionRewriter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Simplification/Reducers/AbstractVisualBasicReducer.AbstractReductionRewriter.vb
@@ -14,6 +14,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
             Private ReadOnly _pool As ObjectPool(Of IReductionRewriter)
 
             Protected CancellationToken As CancellationToken
+            Private _parseOptions As ParseOptions
             Private _simplificationOptions As OptionSet
 
             Private ReadOnly _processedParentNodes As HashSet(Of SyntaxNode) = New HashSet(Of SyntaxNode)()
@@ -26,12 +27,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Simplification
                 _pool = pool
             End Sub
 
-            Public Sub Initialize(optionSet As OptionSet, cancellationToken As CancellationToken) Implements IReductionRewriter.Initialize
+            Public Sub Initialize(parseOptions As ParseOptions, optionSet As OptionSet, cancellationToken As CancellationToken) Implements IReductionRewriter.Initialize
+                _parseOptions = parseOptions
                 _simplificationOptions = optionSet
                 cancellationToken = cancellationToken
             End Sub
 
             Public Sub Dispose() Implements IDisposable.Dispose
+                _parseOptions = Nothing
                 _simplificationOptions = Nothing
                 CancellationToken = CancellationToken.None
                 _processedParentNodes.Clear()

From 3aa377699675af76c60398f6d549e0ccbe6dc896 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 23:12:42 -0700
Subject: [PATCH 204/284] Fixup tests.

---
 .../AddConstructorParametersFromMembersTests.cs                 | 2 +-
 .../Test/CodeGeneration/CodeGenerationTests.CSharp.cs           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/GenerateFromMembers/AddConstructorParametersFromMembers/AddConstructorParametersFromMembersTests.cs b/src/EditorFeatures/CSharpTest/GenerateFromMembers/AddConstructorParametersFromMembers/AddConstructorParametersFromMembersTests.cs
index 374faeb68a7a3..5153ad264ac30 100644
--- a/src/EditorFeatures/CSharpTest/GenerateFromMembers/AddConstructorParametersFromMembers/AddConstructorParametersFromMembersTests.cs
+++ b/src/EditorFeatures/CSharpTest/GenerateFromMembers/AddConstructorParametersFromMembers/AddConstructorParametersFromMembersTests.cs
@@ -159,7 +159,7 @@ public Program(int i)
         this.i = i;
     }
 
-    public Program(int i, string s, bool b = default(bool)) : this(i)
+    public Program(int i, string s, bool b = false) : this(i)
     {
         this.s = s;
         this.b = b;
diff --git a/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.CSharp.cs b/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.CSharp.cs
index 97f8a54e66f33..ff0cc5cd114bb 100644
--- a/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.CSharp.cs
+++ b/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.CSharp.cs
@@ -597,7 +597,7 @@ await TestAddParametersAsync(input, expected,
             public async Task AddDefaultParameterWithDefaultValueToMethod()
             {
                 var input = "class C { public void [|M|]() { } }";
-                var expected = "class C { public void M(double number = default(double)) { } }";
+                var expected = "class C { public void M(double number = 0) { } }";
                 await TestAddParametersAsync(input, expected,
                     Parameters(Parameter(typeof(double), "number", true)));
             }

From f3004af6f482b41754a040f7681c3f25195313c0 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Sun, 14 May 2017 23:49:16 -0700
Subject: [PATCH 205/284] Support default literals in metadata-as-source.

---
 .../MetadataAsSourceGeneratedFileInfo.cs      |  6 ++-
 ...stractMetadataAsSourceTests.TestContext.cs | 25 +++++++--
 .../AbstractMetadataAsSourceTests.cs          |  6 ++-
 .../MetadataAsSource/MetadataAsSourceTests.cs | 25 +++++++++
 .../CSharpMetadataAsSourceService.cs          |  3 +-
 .../CSharp/Portable/CSharpWorkspace.csproj    |  2 +
 .../CSharpSimplificationService.cs            |  3 +-
 ...CSharpDefaultExpressionReducer.Rewriter.cs | 52 +++++++++++++++++++
 .../CSharpDefaultExpressionReducer.cs         | 16 ++++++
 .../CSharpMiscellaneousReducer.Rewriter.cs    | 34 ------------
 .../Reducers/CSharpMiscellaneousReducer.cs    |  1 +
 11 files changed, 130 insertions(+), 43 deletions(-)
 create mode 100644 src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
 create mode 100644 src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.cs

diff --git a/src/EditorFeatures/Core/Implementation/MetadataAsSource/MetadataAsSourceGeneratedFileInfo.cs b/src/EditorFeatures/Core/Implementation/MetadataAsSource/MetadataAsSourceGeneratedFileInfo.cs
index e776783722fd6..de10deb36361f 100644
--- a/src/EditorFeatures/Core/Implementation/MetadataAsSource/MetadataAsSourceGeneratedFileInfo.cs
+++ b/src/EditorFeatures/Core/Implementation/MetadataAsSource/MetadataAsSourceGeneratedFileInfo.cs
@@ -19,9 +19,12 @@ internal sealed class MetadataAsSourceGeneratedFileInfo
 
         public readonly string TemporaryFilePath;
 
+        private readonly ParseOptions _parseOptions;
+
         public MetadataAsSourceGeneratedFileInfo(string rootPath, Project sourceProject, INamedTypeSymbol topLevelNamedType)
         {
             this.SourceProjectId = sourceProject.Id;
+            _parseOptions = sourceProject.ParseOptions;
             this.Workspace = sourceProject.Solution.Workspace;
             this.LanguageName = sourceProject.Language;
             this.References = sourceProject.MetadataReferences.ToImmutableArray();
@@ -79,10 +82,11 @@ public Tuple<ProjectInfo, DocumentId> GetProjectInfoAndDocumentId(Workspace work
                 assemblyName: AssemblyIdentity.Name,
                 language: LanguageName,
                 compilationOptions: compilationOptions,
+                parseOptions: _parseOptions,
                 documents: new[] { assemblyInfoDocument, generatedDocument },
                 metadataReferences: References);
 
             return Tuple.Create(projectInfo, generatedDocumentId);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/EditorFeatures/Test/MetadataAsSource/AbstractMetadataAsSourceTests.TestContext.cs b/src/EditorFeatures/Test/MetadataAsSource/AbstractMetadataAsSourceTests.TestContext.cs
index 4b21f5b6488c4..1bab06c1ae8e6 100644
--- a/src/EditorFeatures/Test/MetadataAsSource/AbstractMetadataAsSourceTests.TestContext.cs
+++ b/src/EditorFeatures/Test/MetadataAsSource/AbstractMetadataAsSourceTests.TestContext.cs
@@ -27,7 +27,12 @@ internal class TestContext : IDisposable
             private readonly IMetadataAsSourceFileService _metadataAsSourceService;
             private readonly ITextBufferFactoryService _textBufferFactoryService;
 
-            public static TestContext Create(string projectLanguage = null, IEnumerable<string> metadataSources = null, bool includeXmlDocComments = false, string sourceWithSymbolReference = null)
+            public static TestContext Create(
+                string projectLanguage = null,
+                IEnumerable<string> metadataSources = null,
+                bool includeXmlDocComments = false,
+                string sourceWithSymbolReference = null,
+                string languageVersion = null)
             {
                 projectLanguage = projectLanguage ?? LanguageNames.CSharp;
                 metadataSources = metadataSources ?? SpecializedCollections.EmptyEnumerable<string>();
@@ -35,7 +40,9 @@ public static TestContext Create(string projectLanguage = null, IEnumerable<stri
                     ? new[] { AbstractMetadataAsSourceTests.DefaultMetadataSource }
                     : metadataSources;
 
-                var workspace = CreateWorkspace(projectLanguage, metadataSources, includeXmlDocComments, sourceWithSymbolReference);
+                var workspace = CreateWorkspace(
+                    projectLanguage, metadataSources, includeXmlDocComments, 
+                    sourceWithSymbolReference, languageVersion);
                 return new TestContext(workspace);
             }
 
@@ -214,11 +221,21 @@ private static string DeduceLanguageString(string input)
                     ? LanguageNames.VisualBasic : LanguageNames.CSharp;
             }
 
-            private static TestWorkspace CreateWorkspace(string projectLanguage, IEnumerable<string> metadataSources, bool includeXmlDocComments, string sourceWithSymbolReference)
+            private static TestWorkspace CreateWorkspace(
+                string projectLanguage, IEnumerable<string> metadataSources, 
+                bool includeXmlDocComments, string sourceWithSymbolReference,
+                string languageVersion)
             {
                 var xmlString = string.Concat(@"
 <Workspace>
-    <Project Language=""", projectLanguage, @""" CommonReferences=""true"">");
+    <Project Language=""", projectLanguage, @""" CommonReferences=""true""");
+
+                if (languageVersion != null)
+                {
+                    xmlString += $@" LanguageVersion=""{languageVersion}""";
+                }
+
+                xmlString += ">";
 
                 metadataSources = metadataSources ?? new[] { AbstractMetadataAsSourceTests.DefaultMetadataSource };
 
diff --git a/src/EditorFeatures/Test/MetadataAsSource/AbstractMetadataAsSourceTests.cs b/src/EditorFeatures/Test/MetadataAsSource/AbstractMetadataAsSourceTests.cs
index ed0a4e53af2ac..d3ea1c1f65cda 100644
--- a/src/EditorFeatures/Test/MetadataAsSource/AbstractMetadataAsSourceTests.cs
+++ b/src/EditorFeatures/Test/MetadataAsSource/AbstractMetadataAsSourceTests.cs
@@ -14,9 +14,11 @@ namespace Microsoft.CodeAnalysis.Editor.UnitTests.MetadataAsSource
 {
     public abstract partial class AbstractMetadataAsSourceTests
     {
-        internal static async Task GenerateAndVerifySourceAsync(string metadataSource, string symbolName, string projectLanguage, string expected, bool ignoreTrivia = true, bool includeXmlDocComments = false)
+        internal static async Task GenerateAndVerifySourceAsync(
+            string metadataSource, string symbolName, string projectLanguage, string expected,
+            bool ignoreTrivia = true, bool includeXmlDocComments = false, string languageVersion = null)
         {
-            using (var context = TestContext.Create(projectLanguage, SpecializedCollections.SingletonEnumerable(metadataSource), includeXmlDocComments))
+            using (var context = TestContext.Create(projectLanguage, SpecializedCollections.SingletonEnumerable(metadataSource), includeXmlDocComments, languageVersion: languageVersion))
             {
                 await context.GenerateAndVerifySourceAsync(symbolName, expected, ignoreTrivia);
             }
diff --git a/src/EditorFeatures/Test/MetadataAsSource/MetadataAsSourceTests.cs b/src/EditorFeatures/Test/MetadataAsSource/MetadataAsSourceTests.cs
index 896854abba14b..4d98730a65216 100644
--- a/src/EditorFeatures/Test/MetadataAsSource/MetadataAsSourceTests.cs
+++ b/src/EditorFeatures/Test/MetadataAsSource/MetadataAsSourceTests.cs
@@ -1360,5 +1360,30 @@ public interface [|IComImport|]
     int Prop {{ get; }}
 }}");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
+        public async Task TestOptionalParameterWithDefaultLiteral()
+        {
+            var metadataSource = @"
+using System.Threading;
+
+public class C {
+    public void M(CancellationToken cancellationToken = default(CancellationToken)) { }
+}";
+            var symbolName = "C";
+
+            await GenerateAndVerifySourceAsync(metadataSource, symbolName, LanguageNames.CSharp, $@"
+#region {FeaturesResources.Assembly} ReferencedAssembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
+// {CodeAnalysisResources.InMemoryAssembly}
+#endregion
+
+using System.Threading;
+
+public class [|C|]
+{{
+    public C();
+    public void M(CancellationToken cancellationToken = default);
+}}", languageVersion: "CSharp7_1");
         }
+    }
 }
\ No newline at end of file
diff --git a/src/Features/CSharp/Portable/MetadataAsSource/CSharpMetadataAsSourceService.cs b/src/Features/CSharp/Portable/MetadataAsSource/CSharpMetadataAsSourceService.cs
index 5bcafc32b91cd..9e9fdf089d33d 100644
--- a/src/Features/CSharp/Portable/MetadataAsSource/CSharpMetadataAsSourceService.cs
+++ b/src/Features/CSharp/Portable/MetadataAsSource/CSharpMetadataAsSourceService.cs
@@ -73,7 +73,8 @@ protected override ImmutableArray<AbstractReducer> GetReducers()
             => ImmutableArray.Create<AbstractReducer>(
                 new CSharpNameReducer(),
                 new CSharpEscapingReducer(),
-                new CSharpParenthesesReducer());
+                new CSharpParenthesesReducer(),
+                new CSharpDefaultExpressionReducer());
 
         private class FormattingRule : AbstractFormattingRule
         {
diff --git a/src/Workspaces/CSharp/Portable/CSharpWorkspace.csproj b/src/Workspaces/CSharp/Portable/CSharpWorkspace.csproj
index 8320354f686e7..5c025eae27d53 100644
--- a/src/Workspaces/CSharp/Portable/CSharpWorkspace.csproj
+++ b/src/Workspaces/CSharp/Portable/CSharpWorkspace.csproj
@@ -98,6 +98,7 @@
     <Compile Include="CodeStyle\TypeStyle\TypeStyle.cs" />
     <Compile Include="CodeStyle\TypeStyle\TypeStyleHelper.cs" />
     <Compile Include="Composition\CSharpWorkspaceFeatures.cs" />
+    <Compile Include="Simplification\Reducers\CSharpDefaultExpressionReducer.Rewriter.cs" />
     <Compile Include="Diagnostics\CSharpDiagnosticPropertiesService.cs" />
     <Compile Include="Execution\CSharpOptionsSerializationService.cs" />
     <Compile Include="Extensions\ArrowExpressionClauseSyntaxExtensions.cs" />
@@ -213,6 +214,7 @@
     <Compile Include="Simplification\Reducers\AbstractCSharpReducer.AbstractReductionRewriter.cs" />
     <Compile Include="Simplification\Reducers\AbstractCSharpReducer.cs" />
     <Compile Include="Simplification\Reducers\CSharpCastReducer.cs" />
+    <Compile Include="Simplification\Reducers\CSharpDefaultExpressionReducer.cs" />
     <Compile Include="Simplification\Reducers\CSharpInferredMemberNameReducer.cs" />
     <Compile Include="Simplification\Reducers\CSharpInferredMemberNameReducer.Rewriter.cs" />
     <Compile Include="Simplification\Reducers\CSharpCastReducer.Rewriter.cs" />
diff --git a/src/Workspaces/CSharp/Portable/Simplification/CSharpSimplificationService.cs b/src/Workspaces/CSharp/Portable/Simplification/CSharpSimplificationService.cs
index 753402d01e18e..cce210504efdd 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/CSharpSimplificationService.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/CSharpSimplificationService.cs
@@ -28,7 +28,8 @@ internal partial class CSharpSimplificationService : AbstractSimplificationServi
                 new CSharpParenthesesReducer(),
                 new CSharpEscapingReducer(),
                 new CSharpMiscellaneousReducer(),
-                new CSharpInferredMemberNameReducer());
+                new CSharpInferredMemberNameReducer(),
+                new CSharpDefaultExpressionReducer());
 
         public CSharpSimplificationService() : base(s_reducers)
         {
diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
new file mode 100644
index 0000000000000..7c96bec49d34e
--- /dev/null
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Options;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.Simplification
+{
+    internal partial class CSharpDefaultExpressionReducer
+    {
+        private class Rewriter : AbstractReductionRewriter
+        {
+            public Rewriter(ObjectPool<IReductionRewriter> pool)
+                : base(pool)
+            {
+                _simplifyDefaultExpression = SimplifyDefaultExpression;
+            }
+
+            private readonly Func<DefaultExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode> _simplifyDefaultExpression;
+
+            private SyntaxNode SimplifyDefaultExpression(
+                DefaultExpressionSyntax node,
+                SemanticModel semanticModel,
+                OptionSet optionSet,
+                CancellationToken cancellationToken)
+            {
+                if (optionSet.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Value &&
+                    node.CanReplaceWithDefaultLiteral(semanticModel, cancellationToken) &&
+                    ((CSharpParseOptions)ParseOptions).LanguageVersion >= LanguageVersion.CSharp7_1)
+                {
+                    return SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
+                                        .WithTriviaFrom(node);
+                }
+
+                return node;
+            }
+
+            public override SyntaxNode VisitDefaultExpression(DefaultExpressionSyntax node)
+            {
+                return SimplifyNode(
+                    node,
+                    newNode: base.VisitDefaultExpression(node),
+                    parentNode: node.Parent,
+                    simplifier: _simplifyDefaultExpression);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.cs
new file mode 100644
index 0000000000000..90975ea6c5821
--- /dev/null
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.cs
@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.Simplification
+{
+    internal partial class CSharpDefaultExpressionReducer : AbstractCSharpReducer
+    {
+        private static readonly ObjectPool<IReductionRewriter> s_pool = new ObjectPool<IReductionRewriter>(
+            () => new Rewriter(s_pool));
+
+        public CSharpDefaultExpressionReducer() : base(s_pool)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs
index efadfd8da46de..c8a1d670ce039 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.Rewriter.cs
@@ -1,11 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System;
-using System.Threading;
-using Microsoft.CodeAnalysis.CSharp.CodeStyle;
-using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Options;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
@@ -17,7 +12,6 @@ private class Rewriter : AbstractReductionRewriter
             public Rewriter(ObjectPool<IReductionRewriter> pool)
                 : base(pool)
             {
-                _simplifyDefaultExpression = SimplifyDefaultExpression;
             }
 
             public override SyntaxNode VisitParameter(ParameterSyntax node)
@@ -46,34 +40,6 @@ public override SyntaxNode VisitBlock(BlockSyntax node)
                     parentNode: node.Parent,
                     simplifier: s_simplifyBlock);
             }
-
-            private readonly Func<DefaultExpressionSyntax, SemanticModel, OptionSet, CancellationToken, SyntaxNode> _simplifyDefaultExpression;
-
-            private SyntaxNode SimplifyDefaultExpression(
-                DefaultExpressionSyntax node,
-                SemanticModel semanticModel,
-                OptionSet optionSet,
-                CancellationToken cancellationToken)
-            {
-                if (optionSet.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Value &&
-                    node.CanReplaceWithDefaultLiteral(semanticModel, cancellationToken) &&
-                    ((CSharpParseOptions)ParseOptions).LanguageVersion >= LanguageVersion.CSharp7_1)
-                {
-                    return SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
-                                        .WithTriviaFrom(node);
-                }
-
-                return node;
-            }
-
-            public override SyntaxNode VisitDefaultExpression(DefaultExpressionSyntax node)
-            {
-                return SimplifyNode(
-                    node,
-                    newNode: base.VisitDefaultExpression(node),
-                    parentNode: node.Parent,
-                    simplifier: _simplifyDefaultExpression);
-            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
index 8a3dbffeaff18..07835daee5ad5 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
@@ -13,6 +13,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
+
     internal partial class CSharpMiscellaneousReducer : AbstractCSharpReducer
     {
         private static readonly ObjectPool<IReductionRewriter> s_pool = new ObjectPool<IReductionRewriter>(

From be03ae09d11352c2dce46b1faa61b61a0e247d58 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 00:17:04 -0700
Subject: [PATCH 206/284] Fix test.

---
 .../CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs b/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs
index 30008ce23fcc0..f6e2c8a4f71c3 100644
--- a/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs
+++ b/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs
@@ -212,7 +212,7 @@ class C
 {
     void Foo(bool b)
     {
-        string s1 = b ? {|FixAllInDocument:default|}(string) : defalut(string);
+        string s1 = b ? {|FixAllInDocument:default|}(string) : default(string);
     }
 }",
 @"
@@ -220,7 +220,7 @@ class C
 {
     void Foo(bool b)
     {
-        string s1 = b ? default : defalut(string);
+        string s1 = b ? default : default(string);
     }
 }", parseOptions: s_parseOptions);
         }

From 46643bb0b59cbc2f5d18b180534f558ad60aab91 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 00:18:25 -0700
Subject: [PATCH 207/284] Formatting.

---
 .../CSharpUseDefaultLiteralDiagnosticAnalyzer.cs                 | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
index 644316141d4dd..44ad91cf18c6f 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
@@ -14,7 +14,6 @@ namespace Microsoft.CodeAnalysis.CSharp.UseDefaultLiteral
     [DiagnosticAnalyzer(LanguageNames.CSharp)]
     internal class CSharpUseDefaultLiteralDiagnosticAnalyzer : AbstractCodeStyleDiagnosticAnalyzer
     {
-
         public CSharpUseDefaultLiteralDiagnosticAnalyzer() 
             : base(IDEDiagnosticIds.UseDefaultLiteralDiagnosticId,
                    new LocalizableResourceString(

From ee580a842273e103a4da95ee514ef9543b93bf40 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 00:20:10 -0700
Subject: [PATCH 208/284] Simplify code.

---
 .../Reducers/CSharpDefaultExpressionReducer.Rewriter.cs       | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
index 7c96bec49d34e..871bc4e3133c2 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
@@ -29,8 +29,8 @@ private SyntaxNode SimplifyDefaultExpression(
                 CancellationToken cancellationToken)
             {
                 if (optionSet.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Value &&
-                    node.CanReplaceWithDefaultLiteral(semanticModel, cancellationToken) &&
-                    ((CSharpParseOptions)ParseOptions).LanguageVersion >= LanguageVersion.CSharp7_1)
+                    ((CSharpParseOptions)ParseOptions).LanguageVersion >= LanguageVersion.CSharp7_1 &&
+                    node.CanReplaceWithDefaultLiteral(semanticModel, cancellationToken))
                 {
                     return SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
                                         .WithTriviaFrom(node);

From 006df243d020324c6d946d15c554306631506f2c Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 00:20:38 -0700
Subject: [PATCH 209/284] Simplify code.

---
 .../AbstractCSharpReducer.AbstractReductionRewriter.cs        | 4 ++--
 .../Reducers/CSharpDefaultExpressionReducer.Rewriter.cs       | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.AbstractReductionRewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.AbstractReductionRewriter.cs
index 86ddbd17a525f..91adbdce74f40 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.AbstractReductionRewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/AbstractCSharpReducer.AbstractReductionRewriter.cs
@@ -18,7 +18,7 @@ protected abstract class AbstractReductionRewriter : CSharpSyntaxRewriter, IRedu
         {
             private readonly ObjectPool<IReductionRewriter> _pool;
 
-            protected ParseOptions ParseOptions { get; private set; }
+            protected CSharpParseOptions ParseOptions { get; private set; }
             private OptionSet _optionSet;
             private CancellationToken _cancellationToken;
             private SemanticModel _semanticModel;
@@ -36,7 +36,7 @@ protected AbstractReductionRewriter(ObjectPool<IReductionRewriter> pool)
 
             public void Initialize(ParseOptions parseOptions, OptionSet optionSet, CancellationToken cancellationToken)
             {
-                ParseOptions = parseOptions;
+                ParseOptions = (CSharpParseOptions)parseOptions;
                 _optionSet = optionSet;
                 _cancellationToken = cancellationToken;
             }
diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
index 871bc4e3133c2..738c1b6630591 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
@@ -29,7 +29,7 @@ private SyntaxNode SimplifyDefaultExpression(
                 CancellationToken cancellationToken)
             {
                 if (optionSet.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Value &&
-                    ((CSharpParseOptions)ParseOptions).LanguageVersion >= LanguageVersion.CSharp7_1 &&
+                    ParseOptions.LanguageVersion >= LanguageVersion.CSharp7_1 &&
                     node.CanReplaceWithDefaultLiteral(semanticModel, cancellationToken))
                 {
                     return SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)

From 8f804a73ab7a1cd414ca1c4866039d3e3cc6e110 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 00:21:13 -0700
Subject: [PATCH 210/284] Formatting.

---
 .../Simplification/Reducers/CSharpMiscellaneousReducer.cs        | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
index 07835daee5ad5..8a3dbffeaff18 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpMiscellaneousReducer.cs
@@ -13,7 +13,6 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.Simplification
 {
-
     internal partial class CSharpMiscellaneousReducer : AbstractCSharpReducer
     {
         private static readonly ObjectPool<IReductionRewriter> s_pool = new ObjectPool<IReductionRewriter>(

From 490973a8e39c9776ce5e4cfeaa0cd24f168154fd Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 00:22:26 -0700
Subject: [PATCH 211/284] Remove unnecessary casts.

---
 .../Core/Portable/Utilities/AbstractSpeculationAnalyzer.cs    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Utilities/AbstractSpeculationAnalyzer.cs b/src/Workspaces/Core/Portable/Utilities/AbstractSpeculationAnalyzer.cs
index 7f71e5cd86c9c..a0a7a3ecc505d 100644
--- a/src/Workspaces/Core/Portable/Utilities/AbstractSpeculationAnalyzer.cs
+++ b/src/Workspaces/Core/Portable/Utilities/AbstractSpeculationAnalyzer.cs
@@ -439,8 +439,8 @@ protected bool ReplacementChangesSemantics(SyntaxNode currentOriginalNode, Synta
 
                 previousOriginalNode = currentOriginalNode;
                 previousReplacedNode = currentReplacedNode;
-                currentOriginalNode = (SyntaxNode)currentOriginalNode.Parent;
-                currentReplacedNode = (SyntaxNode)currentReplacedNode.Parent;
+                currentOriginalNode = currentOriginalNode.Parent;
+                currentReplacedNode = currentReplacedNode.Parent;
                 skipVerificationForCurrentNode = skipVerificationForCurrentNode && IsParenthesizedExpression(currentReplacedNode);
             }
 

From 28f00685b48deabb3b15f05f954fa327c4dcbea1 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Mon, 15 May 2017 00:38:46 -0700
Subject: [PATCH 212/284] Mark recently completed C# 7.1 features as such
 (#19483)

---
 docs/Language Feature Status.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/Language Feature Status.md b/docs/Language Feature Status.md
index ab18ef653b598..4ad73499c3690 100644
--- a/docs/Language Feature Status.md	
+++ b/docs/Language Feature Status.md	
@@ -10,11 +10,11 @@ efforts behind them.
 
 | Feature | Branch | State | Developers | Reviewer | LDM Champ |
 | ------- | ------ | ----- | ---------- | -------- | --------- |
-| [Async Main](https://github.com/dotnet/csharplang/blob/master/proposals/async-main.md) | [async-main](https://github.com/dotnet/roslyn/tree/features/async-main)  | Prototype | [tyoverby](https://github.com/tyoverby) | [vsadov](https://github.com/vsadov) | [stephentoub](https://github.com/stephentoub) |
+| [Async Main](https://github.com/dotnet/csharplang/blob/master/proposals/async-main.md) | master | Merged | [tyoverby](https://github.com/tyoverby) | [vsadov](https://github.com/vsadov) | [stephentoub](https://github.com/stephentoub) |
 | [Default Expressions](https://github.com/dotnet/csharplang/blob/master/proposals/target-typed-default.md) | master  | Merged | [jcouv](https://github.com/jcouv) | [cston](https://github.com/cston) | [jcouv](https://github.com/jcouv) |
-| [Ref Assemblies](https://github.com/dotnet/roslyn/blob/features/refout/docs/features/refout.md) | [refout](https://github.com/dotnet/roslyn/tree/features/refout)  | Integration & validation | [jcouv](https://github.com/jcouv) | [gafter](https://github.com/gafter) | N/A |
-| [Infer tuple names](https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.1/infer-tuple-names.md) | master  | Merged | [jcouv](https://github.com/jcouv) | [gafter](https://github.com/gafter) | [jcouv](https://github.com/jcouv) |
-| [Pattern-matching with generics](https://github.com/dotnet/csharplang/blob/master/proposals/generics-pattern-match.md) | https://github.com/dotnet/roslyn/pull/18784  | Implementation | [gafter](https://github.com/gafter) | [agocke](https://github.com/agocke) | [gafter](https://github.com/gafter) |
+| [Ref Assemblies](https://github.com/dotnet/roslyn/blob/master/docs/features/refout.md) | master | Merged (MSBuild integration ongoing) | [jcouv](https://github.com/jcouv) | [gafter](https://github.com/gafter) | N/A |
+| [Infer tuple names](https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.1/infer-tuple-names.md) | master | Merged | [jcouv](https://github.com/jcouv) | [gafter](https://github.com/gafter) | [jcouv](https://github.com/jcouv) |
+| [Pattern-matching with generics](https://github.com/dotnet/csharplang/blob/master/proposals/generics-pattern-match.md) | master  | Merged | [gafter](https://github.com/gafter) | [agocke](https://github.com/agocke) | [gafter](https://github.com/gafter) |
 
 # C# 7.2
 

From 24bff7e79b76ba1f895e3acc88f184f50b7edc33 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Mon, 15 May 2017 01:38:22 -0700
Subject: [PATCH 213/284] Add IsLeftOfAssignment field to BoundIndexerAccess
 and fix indexer IArgument

---
 .../Portable/Binder/Binder_Expressions.cs     |   1 +
 .../Portable/Binder/Binder_Statements.cs      |  20 +++-
 .../CSharp/Portable/BoundTree/BoundNodes.xml  |   3 +-
 .../CSharp/Portable/BoundTree/Constructors.cs |   1 +
 .../CSharp/Portable/BoundTree/Expression.cs   |  43 +++++++-
 .../Generated/BoundNodes.xml.Generated.cs     |  14 ++-
 .../LocalRewriter/LocalRewriter_Call.cs       |  48 ++++++---
 ...ocalRewriter_CompoundAssignmentOperator.cs |   1 +
 .../LocalRewriter_IndexerAccess.cs            |   4 +-
 .../IOperation/IOperationTests_IArgument.cs   | 100 +++++++++++++++---
 10 files changed, 192 insertions(+), 43 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
index 2b9452c975350..2ad354f450c33 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
@@ -6830,6 +6830,7 @@ private BoundExpression BindIndexerOrIndexedPropertyAccess(
                     isExpanded,
                     argsToParams,
                     this,
+                    false,
                     property.Type,
                     gotError);
             }
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
index af58cb970d4e1..8ddf4b183f381 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
@@ -1744,7 +1744,7 @@ private BoundExpression InferTypeForDiscardAssignment(BoundDiscardExpression op1
         }
 
         private BoundAssignmentOperator BindAssignment(SyntaxNode node, BoundExpression op1, BoundExpression op2, DiagnosticBag diagnostics)
-        {
+        {                      
             Debug.Assert(op1 != null);
             Debug.Assert(op2 != null);
 
@@ -1773,7 +1773,7 @@ private BoundAssignmentOperator BindAssignment(SyntaxNode node, BoundExpression
             {
                 // Event assignment is a call to void WindowsRuntimeMarshal.AddEventHandler<T>().
                 type = this.GetSpecialType(SpecialType.System_Void, diagnostics, node);
-            }
+            } 
             else
             {
                 type = op1.Type;
@@ -1933,6 +1933,22 @@ private BoundExpression CheckValue(BoundExpression expr, BindValueKind valueKind
                         GetNonMethodMemberType(otherSymbol));
                 }
             }
+            else if (expr.Kind == BoundKind.IndexerAccess && valueKind == BindValueKind.Assignment)
+            {
+                // Assigning to an indexer access, need to set 'isLeftOfAssignment' to true.
+                // This is for IOperation purpose.
+                var indexerAccess = (BoundIndexerAccess)expr;
+                expr = indexerAccess.Update(indexerAccess.ReceiverOpt,
+                    indexerAccess.Indexer,
+                    indexerAccess.Arguments,
+                    indexerAccess.ArgumentNamesOpt,
+                    indexerAccess.ArgumentRefKindsOpt,
+                    indexerAccess.Expanded,
+                    indexerAccess.ArgsToParamsOpt,
+                    indexerAccess.BinderOpt,
+                    isLeftOfAssignment: true,
+                    type: indexerAccess.Type);
+            }
 
             if (!hasResolutionErrors && CheckValueKind(expr, valueKind, diagnostics) ||
                 expr.HasAnyErrors && valueKind == BindValueKind.RValueOrMethodGroup)
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index cec1c250b9f4f..7fac0d4f3de67 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -1498,8 +1498,9 @@
     <Field Name="Expanded" Type="bool"/>
     <Field Name="ArgsToParamsOpt" Type="ImmutableArray&lt;int&gt;" Null="allow"/>
 
-    <!-- BinderOpt is added as a temporary solution for IOperation implementation and should probably be removed in the future -->
+    <!-- BinderOpt and IsLeftOfAssignment are added as a temporary solution for IOperation implementation and should probably be removed in the future -->
     <Field Name="BinderOpt" Type="Binder" Null="allow"/>
+    <Field Name="IsLeftOfAssignment" Type="bool"/>
   </Node>
 
   <Node Name="BoundDynamicIndexerAccess" Base="BoundExpression">
diff --git a/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs b/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
index 8d3b70508fccc..828728a47e4d5 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
@@ -164,6 +164,7 @@ public static BoundIndexerAccess ErrorAccess(
                 expanded: false,
                 argsToParamsOpt: default(ImmutableArray<int>),
                 binderOpt: null,
+                isLeftOfAssignment: false,
                 type: indexer.Type,
                 hasErrors: true)
             {
diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index 225a1de8a2905..6922c87042c73 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -115,12 +115,14 @@ internal static ImmutableArray<IArgument> DeriveArguments(
             return (ImmutableArray<IArgument>) s_callToArgumentsMappings.GetValue(
                 boundNode, 
                 (n) =>
-                {
+                {                          
                     //TODO: https://github.com/dotnet/roslyn/issues/18722
                     //      Right now, for erroneous code, we exposes all expression in place of arguments as IArgument with Parameter set to null,
                     //      so user needs to check IsInvalid first before using anything we returned. Need to implement a new interface for invalid invocation instead.
-                    if (n.HasErrors)
+                    if (n.HasErrors || optionalParametersMethod == null)
                     {
+                        // optionalParametersMethod can be null if we are writing to a readonly indexer or reading from an writeonly indexer,
+                        // in which case HasErrors property would be true, but we still want to treat this as invalid invocation.
                         ArrayBuilder<IArgument> argumentsWithErrors = ArrayBuilder<IArgument>.GetInstance(boundArguments.Length);
                         for (int a = 0; a < boundArguments.Length; ++a)
                         {
@@ -209,8 +211,29 @@ internal partial class BoundIndexerAccess : IIndexedPropertyReferenceExpression
 
         ISymbol IMemberReferenceExpression.Member => this.Indexer;
 
-        ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder 
-            => BoundCall.DeriveArguments(this, this.BinderOpt, this.Indexer, this.Indexer.GetOwnOrInheritedGetMethod(),this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Indexer.Parameters, this.Expanded, this.Syntax);
+        ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder
+        {
+            get
+            {
+                MethodSymbol accessor = this.IsLeftOfAssignment ? this.Indexer.SetMethod : this.Indexer.GetMethod; 
+                return BoundCall.DeriveArguments(this, 
+                    this.BinderOpt, 
+                    this.Indexer, 
+                    accessor, 
+                    this.Arguments, 
+                    this.ArgumentNamesOpt, 
+                    this.ArgsToParamsOpt, 
+                    this.ArgumentRefKindsOpt, 
+                    this.Indexer.Parameters, 
+                    this.Expanded, 
+                    this.Syntax);
+            }
+        }
+
+        bool IOperation.IsInvalid
+             => this.HasErrors 
+            || (this.Indexer.IsReadOnly && this.IsLeftOfAssignment) 
+            || (this.Indexer.IsWriteOnly && !this.IsLeftOfAssignment);
 
         protected override OperationKind ExpressionKind => OperationKind.IndexedPropertyReferenceExpression;
 
@@ -345,7 +368,17 @@ internal partial class BoundObjectCreationExpression : IObjectCreationExpression
         IMethodSymbol IObjectCreationExpression.Constructor => this.Constructor;
 
         ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder 
-            => BoundCall.DeriveArguments(this, this.BinderOpt, this.Constructor, this.Constructor, this.Arguments, this.ArgumentNamesOpt, this.ArgsToParamsOpt, this.ArgumentRefKindsOpt, this.Constructor.Parameters, this.Expanded, this.Syntax);
+            => BoundCall.DeriveArguments(this, 
+                this.BinderOpt,
+                this.Constructor, 
+                this.Constructor, 
+                this.Arguments, 
+                this.ArgumentNamesOpt,
+                this.ArgsToParamsOpt, 
+                this.ArgumentRefKindsOpt, 
+                this.Constructor.Parameters, 
+                this.Expanded, 
+                this.Syntax);
 
         ImmutableArray<IOperation> IObjectCreationExpression.Initializers => GetChildInitializers(this.InitializerExpressionOpt).As<IOperation>();
 
diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
index 8c22c1a29ae14..7f36d954c5543 100644
--- a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
@@ -5424,7 +5424,7 @@ public BoundEventAccess Update(BoundExpression receiverOpt, EventSymbol eventSym
 
     internal sealed partial class BoundIndexerAccess : BoundExpression
     {
-        public BoundIndexerAccess(SyntaxNode syntax, BoundExpression receiverOpt, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, Binder binderOpt, TypeSymbol type, bool hasErrors = false)
+        public BoundIndexerAccess(SyntaxNode syntax, BoundExpression receiverOpt, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, Binder binderOpt, bool isLeftOfAssignment, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.IndexerAccess, syntax, type, hasErrors || receiverOpt.HasErrors() || arguments.HasErrors())
         {
 
@@ -5440,6 +5440,7 @@ public BoundIndexerAccess(SyntaxNode syntax, BoundExpression receiverOpt, Proper
             this.Expanded = expanded;
             this.ArgsToParamsOpt = argsToParamsOpt;
             this.BinderOpt = binderOpt;
+            this.IsLeftOfAssignment = isLeftOfAssignment;
         }
 
 
@@ -5459,16 +5460,18 @@ public BoundIndexerAccess(SyntaxNode syntax, BoundExpression receiverOpt, Proper
 
         public Binder BinderOpt { get; }
 
+        public bool IsLeftOfAssignment { get; }
+
         public override BoundNode Accept(BoundTreeVisitor visitor)
         {
             return visitor.VisitIndexerAccess(this);
         }
 
-        public BoundIndexerAccess Update(BoundExpression receiverOpt, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, Binder binderOpt, TypeSymbol type)
+        public BoundIndexerAccess Update(BoundExpression receiverOpt, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, Binder binderOpt, bool isLeftOfAssignment, TypeSymbol type)
         {
-            if (receiverOpt != this.ReceiverOpt || indexer != this.Indexer || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || argumentRefKindsOpt != this.ArgumentRefKindsOpt || expanded != this.Expanded || argsToParamsOpt != this.ArgsToParamsOpt || binderOpt != this.BinderOpt || type != this.Type)
+            if (receiverOpt != this.ReceiverOpt || indexer != this.Indexer || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || argumentRefKindsOpt != this.ArgumentRefKindsOpt || expanded != this.Expanded || argsToParamsOpt != this.ArgsToParamsOpt || binderOpt != this.BinderOpt || isLeftOfAssignment != this.IsLeftOfAssignment || type != this.Type)
             {
-                var result = new BoundIndexerAccess(this.Syntax, receiverOpt, indexer, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, binderOpt, type, this.HasErrors);
+                var result = new BoundIndexerAccess(this.Syntax, receiverOpt, indexer, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, binderOpt, isLeftOfAssignment, type, this.HasErrors);
                 result.WasCompilerGenerated = this.WasCompilerGenerated;
                 return result;
             }
@@ -9133,7 +9136,7 @@ public override BoundNode VisitIndexerAccess(BoundIndexerAccess node)
             BoundExpression receiverOpt = (BoundExpression)this.Visit(node.ReceiverOpt);
             ImmutableArray<BoundExpression> arguments = (ImmutableArray<BoundExpression>)this.VisitList(node.Arguments);
             TypeSymbol type = this.VisitType(node.Type);
-            return node.Update(receiverOpt, node.Indexer, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.BinderOpt, type);
+            return node.Update(receiverOpt, node.Indexer, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.BinderOpt, node.IsLeftOfAssignment, type);
         }
         public override BoundNode VisitDynamicIndexerAccess(BoundDynamicIndexerAccess node)
         {
@@ -10614,6 +10617,7 @@ public override TreeDumperNode VisitIndexerAccess(BoundIndexerAccess node, objec
                 new TreeDumperNode("expanded", node.Expanded, null),
                 new TreeDumperNode("argsToParamsOpt", node.ArgsToParamsOpt, null),
                 new TreeDumperNode("binderOpt", node.BinderOpt, null),
+                new TreeDumperNode("isLeftOfAssignment", node.IsLeftOfAssignment, null),
                 new TreeDumperNode("type", node.Type, null)
             }
             );
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index 3638ddcc4bf56..2867d1824080c 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -543,7 +543,7 @@ internal static ImmutableArray<IArgument> MakeArgumentsInEvaluationOrder(
                 argumentsInEvaluationBuilder, 
                 missingParametersBuilder);
 
-            AppendMissingOptionalArguments(syntax, methodOrIndexer, expanded, binder, missingParametersBuilder.ToImmutableAndFree(), argumentsInEvaluationBuilder);
+            AppendMissingOptionalArguments(syntax, optionalParametersMethod, expanded, binder, missingParametersBuilder.ToImmutableAndFree(), argumentsInEvaluationBuilder);
 
             return argumentsInEvaluationBuilder.ToImmutableAndFree();
         }
@@ -836,7 +836,7 @@ private static BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue cons
             }
             else
             {
-                return new BoundLiteral(syntax, constantValue, type);
+                return new BoundLiteral(syntax, constantValue, type, constantValue.IsBad);
             }
         }
 
@@ -986,35 +986,51 @@ private void InsertMissingOptionalArguments(SyntaxNode syntax,
             }
         }
 
-        private static void AppendMissingOptionalArguments(SyntaxNode syntax,
-            Symbol methodOrIndexer,
+        private static void AppendMissingOptionalArguments(SyntaxNode syntax,  
+            MethodSymbol optionalParametersMethod,
             bool expanded, 
             Binder binder,
             ImmutableArray<ParameterSymbol> missingParameters,
             ArrayBuilder<IArgument> argumentsBuilder)
         {
-            ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters();
-            foreach (var parameter in missingParameters)
+            ImmutableArray<ParameterSymbol> parametersOfOptionalParametersMethod = optionalParametersMethod.Parameters; 
+
+            foreach (ParameterSymbol parameter in missingParameters)
             {
-                if (expanded && parameter.Ordinal == parameters.Length - 1)
+                BoundExpression argument;
+                ArgumentKind kind;
+
+                // In case of indexer access, missing parameters are corresponding to the indexer symbol, we need to 
+                // get default values base on actual accessor method parameter symbols (but still want to tie resulted IArgument 
+                // to the indexer parameter.)
+                ParameterSymbol parameterOfOptionalParametersMethod = parametersOfOptionalParametersMethod[parameter.Ordinal];
+
+                if (expanded && parameterOfOptionalParametersMethod.Ordinal == parametersOfOptionalParametersMethod.Length - 1)
                 {
-                    Debug.Assert(parameter.IsParams);
+                    Debug.Assert(parameterOfOptionalParametersMethod.IsParams);
 
                     // Create an empty array for omitted param array argument.
-                    var paramArray = CreateParamArrayArgument(syntax, parameter.Type, ImmutableArray<BoundExpression>.Empty, null, binder);
-
-                    argumentsBuilder.Add(BoundCall.CreateArgumentOperation(ArgumentKind.ParamArray, parameter, paramArray)); 
+                    argument = CreateParamArrayArgument(syntax, parameterOfOptionalParametersMethod.Type, ImmutableArray<BoundExpression>.Empty, null, binder);
+                    kind = ArgumentKind.ParamArray;                                                                               
                 }
                 else
                 {
-                    Debug.Assert(parameter.IsOptional);
+                    Debug.Assert(parameterOfOptionalParametersMethod.IsOptional);
 
                     var unusedDiagnostics = DiagnosticBag.GetInstance();
-                    var defaultArgument = GetDefaultParameterValue(syntax, parameter, enableCallerInfo: ThreeState.Unknown, localRewriter: null, binder: binder, diagnostics: unusedDiagnostics);
-                    unusedDiagnostics.Free();
 
-                    argumentsBuilder.Add(BoundCall.CreateArgumentOperation(ArgumentKind.DefaultValue, parameter, defaultArgument));
-                }                               
+                    argument = GetDefaultParameterValue(syntax,
+                        parameterOfOptionalParametersMethod, 
+                        enableCallerInfo: ThreeState.Unknown, 
+                        localRewriter: null, 
+                        binder: binder, 
+                        diagnostics: unusedDiagnostics);
+                    kind = ArgumentKind.DefaultValue;
+
+                    unusedDiagnostics.Free();                                                                                       
+                }                                                              
+
+                argumentsBuilder.Add(BoundCall.CreateArgumentOperation(kind, parameter, argument));
             }                                                               
         }
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs
index 891b2dc430380..c1afe91fc325e 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs
@@ -329,6 +329,7 @@ private BoundIndexerAccess TransformIndexerAccess(BoundIndexerAccess indexerAcce
                 false,
                 default(ImmutableArray<int>),
                 null,
+                indexerAccess.IsLeftOfAssignment,
                 indexerAccess.Type);
         }
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_IndexerAccess.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_IndexerAccess.cs
index 628a768ab72b9..888ca6650eb3b 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_IndexerAccess.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_IndexerAccess.cs
@@ -105,8 +105,8 @@ private BoundExpression MakeIndexerAccess(
                 // This node will be rewritten with MakePropertyAssignment when rewriting the enclosing BoundAssignmentOperator.
 
                 return oldNodeOpt != null ?
-                    oldNodeOpt.Update(rewrittenReceiver, indexer, rewrittenArguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, null, type) :
-                    new BoundIndexerAccess(syntax, rewrittenReceiver, indexer, rewrittenArguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, null, type);
+                    oldNodeOpt.Update(rewrittenReceiver, indexer, rewrittenArguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, null, isLeftOfAssignment, type) :
+                    new BoundIndexerAccess(syntax, rewrittenReceiver, indexer, rewrittenArguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, null, isLeftOfAssignment, type);
             }
             else
             {
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index 068945739376c..f853c86b6fe5d 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -1,5 +1,5 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
+                                                                
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Xunit;
@@ -988,7 +988,7 @@ void M2(string x )
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip ="todo")]
+        [Fact]
         public void InvalidConversionForDefaultArgument()
         {
             string source = @"
@@ -1018,9 +1018,9 @@ void M2(int x = ""string"")
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "todo")]
-        public void AssigningToIndexerSetter()
-        {
+        [Fact]
+        public void AssigningToIndexer()
+        {                      
             string source = @"
 class P
 {
@@ -1048,8 +1048,8 @@ void M1()
             VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "todo")]
-        public void AssigningToWriteOnlyIndexer()
+        [Fact]
+        public void ReadingFromIndexer()
         {
             string source = @"
 class P
@@ -1057,17 +1057,18 @@ class P
     private int _number = 0;
     public int this[int index]
     {
+        get { return _number; }
         set { _number = value; }
     }
 
     void M1()
     {
-        /*<bind>*/this[10]/*</bind>*/ = 9;
+        var x = /*<bind>*/this[10]/*</bind>*/;
     }
 }
 ";
             string expectedOperationTree = @"
-IIndexedPropertyReferenceExpression: System.Int32 P.this[System.Int32 index] { set; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32) (Syntax: 'this[10]')
+IIndexedPropertyReferenceExpression: System.Int32 P.this[System.Int32 index] { get; set; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32) (Syntax: 'this[10]')
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Explicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'this')
   Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: index) (OperationKind.Argument) (Syntax: '10')
       ILiteralExpression (Text: 10) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 10) (Syntax: '10')
@@ -1077,7 +1078,72 @@ void M1()
             VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
 
-        [Fact(Skip = "todo")]
+        [Fact]
+        public void DefaultArgumentForIndexerGetter()
+        {                     
+            string source = @"
+class P
+{
+    private int _number = 0;
+    public int this[int i = 1, int j = 2]
+    {
+        get { return _number; }
+        set { _number = i + j; }
+    }
+
+    void M1()
+    {
+        var x = /*<bind>*/this[j:10]/*</bind>*/;
+    }
+}
+";
+            string expectedOperationTree = @"
+IIndexedPropertyReferenceExpression: System.Int32 P.this[[System.Int32 i = 1], [System.Int32 j = 2]] { get; set; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32) (Syntax: 'this[j:10]')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Explicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'this')
+  Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: j) (OperationKind.Argument) (Syntax: '10')
+      ILiteralExpression (Text: 10) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 10) (Syntax: '10')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: i) (OperationKind.Argument) (Syntax: 'this[j:10]')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: 'this[j:10]')
+";
+
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [Fact]
+        public void ReadingFromWriteOnlyIndexer()
+        {
+            string source = @"
+class P
+{
+    private int _number = 0;
+    public int this[int index]
+    {
+        set { _number = value; }
+    }
+
+    void M1()
+    {
+        var x = /*<bind>*/this[10]/*</bind>*/;
+    }
+}
+";
+            string expectedOperationTree = @"
+IIndexedPropertyReferenceExpression: System.Int32 P.this[System.Int32 index] { set; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32, IsInvalid) (Syntax: 'this[10]')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Explicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'this')
+  Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: null) (OperationKind.Argument, IsInvalid) (Syntax: '10')
+      ILiteralExpression (Text: 10) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 10) (Syntax: '10')";
+            var expectedDiagnostics = new DiagnosticDescription[] {               
+                // file.cs(12,27): error CS0154: The property or indexer 'P.this[int]' cannot be used in this context because it lacks the get accessor
+                //         var x = /*<bind>*/this[10]/*</bind>*/;
+                Diagnostic(ErrorCode.ERR_PropertyLacksGet, "this[10]").WithArguments("P.this[int]").WithLocation(12, 27)
+            };
+
+            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [Fact]
         public void AssigningToReadOnlyIndexer()
         {
             string source = @"
@@ -1095,8 +1161,18 @@ void M1()
     }
 }
 ";
-            string expectedOperationTree = @"";
-            var expectedDiagnostics = DiagnosticDescription.None;
+            string expectedOperationTree = @"
+IIndexedPropertyReferenceExpression: System.Int32 P.this[System.Int32 index] { get; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32, IsInvalid) (Syntax: 'this[10]')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Explicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'this')
+  Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: null) (OperationKind.Argument, IsInvalid) (Syntax: '10')
+      ILiteralExpression (Text: 10) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 10) (Syntax: '10')
+";
+
+            var expectedDiagnostics = new DiagnosticDescription[] {
+                // file.cs(12,19): error CS0200: Property or indexer 'P.this[int]' cannot be assigned to -- it is read only
+                //         /*<bind>*/this[10]/*</bind>*/ = 9;
+                Diagnostic(ErrorCode.ERR_AssgReadonlyProp, "this[10]").WithArguments("P.this[int]").WithLocation(12, 19)
+            };
 
             VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }

From ab816bae265706d84819686a1a3d6df223c5b417 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 02:20:37 -0700
Subject: [PATCH 214/284] Update comment.

---
 .../CSharpUseDefaultLiteralCodeFixProvider.cs                  | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
index 4af924ba91385..db4316dfe4421 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
@@ -38,6 +38,9 @@ protected override async Task FixAllAsync(
             // may make the next case unfixable.  For example:
             //
             //    'var v = x ? default(string) : default(string)'.
+            //
+            // Here, we can replace either of the default expressions, but not both. So we have 
+            // to replace one at a time, and only actually replace if it's still safe to do so.
 
             var workspace = document.Project.Solution.Workspace;
             var originalRoot = editor.OriginalRoot;

From 277715df8325e1a92ba17ad5f7d0d02fc7a03375 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 02:22:05 -0700
Subject: [PATCH 215/284] Simplify code.

---
 .../CSharpUseDefaultLiteralCodeFixProvider.cs   | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
index db4316dfe4421..8de2a8685e31f 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
@@ -60,7 +60,11 @@ protected override async Task FixAllAsync(
 
                 if (defaultExpression.CanReplaceWithDefaultLiteral(semanticModel, cancellationToken))
                 {
-                    document = FixOne(document, currentRoot, defaultExpression);
+                    var replacement = SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
+                                                   .WithTriviaFrom(defaultExpression);
+
+                    document = document.WithSyntaxRoot(currentRoot.ReplaceNode(defaultExpression, replacement));
+
                     semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
                     currentRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
                 }
@@ -69,17 +73,6 @@ protected override async Task FixAllAsync(
             editor.ReplaceNode(originalRoot, currentRoot);
         }
 
-        private static Document FixOne(
-            Document document, SyntaxNode currentRoot, DefaultExpressionSyntax defaultExpression)
-        {
-            var replacement = SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
-                                           .WithTriviaFrom(defaultExpression);
-
-            var newRoot = currentRoot.ReplaceNode(defaultExpression, replacement);
-
-            return document.WithSyntaxRoot(newRoot);
-        }
-
         private class MyCodeAction : CodeAction.DocumentChangeAction
         {
             public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)

From cf967be14350d96bdf55d259bfc364a52c6b88a8 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 02:25:51 -0700
Subject: [PATCH 216/284] Move version checking to single location.

---
 .../CSharpUseDefaultLiteralCodeFixProvider.cs               | 3 ++-
 .../CSharpUseDefaultLiteralDiagnosticAnalyzer.cs            | 2 +-
 .../Extensions/DefaultExpressionSyntaxExtensions.cs         | 6 ++++++
 .../Reducers/CSharpDefaultExpressionReducer.Rewriter.cs     | 3 +--
 4 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
index 8de2a8685e31f..060c9367eb2db 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
@@ -42,6 +42,7 @@ protected override async Task FixAllAsync(
             // Here, we can replace either of the default expressions, but not both. So we have 
             // to replace one at a time, and only actually replace if it's still safe to do so.
 
+            var parseOptions = (CSharpParseOptions)document.Project.ParseOptions;
             var workspace = document.Project.Solution.Workspace;
             var originalRoot = editor.OriginalRoot;
 
@@ -58,7 +59,7 @@ protected override async Task FixAllAsync(
             {
                 var defaultExpression = currentRoot.GetCurrentNode(originalDefaultExpression);
 
-                if (defaultExpression.CanReplaceWithDefaultLiteral(semanticModel, cancellationToken))
+                if (defaultExpression.CanReplaceWithDefaultLiteral(parseOptions, semanticModel, cancellationToken))
                 {
                     var replacement = SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
                                                    .WithTriviaFrom(defaultExpression);
diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
index 44ad91cf18c6f..bbf26a9d44483 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
@@ -55,7 +55,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
             }
 
             var defaultExpression = (DefaultExpressionSyntax)context.Node;
-            if (!defaultExpression.CanReplaceWithDefaultLiteral(context.SemanticModel, cancellationToken))
+            if (!defaultExpression.CanReplaceWithDefaultLiteral(parseOptions, context.SemanticModel, cancellationToken))
             {
                 return;
             }
diff --git a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
index 3d90f6d356f3e..2e9d4f6143067 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
@@ -12,9 +12,15 @@ internal static class DefaultExpressionSyntaxExtensions
 
         public static bool CanReplaceWithDefaultLiteral(
             this DefaultExpressionSyntax defaultExpression,
+            CSharpParseOptions parseOptions,
             SemanticModel semanticModel,
             CancellationToken cancellationToken)
         {
+            if (parseOptions.LanguageVersion < LanguageVersion.CSharp7_1)
+            {
+                return false;
+            }
+
             var speculationAnalyzer = new SpeculationAnalyzer(
                 defaultExpression, s_defaultLiteralExpression, semanticModel,
                 cancellationToken,
diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
index 738c1b6630591..ab3d528a70edb 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
@@ -29,8 +29,7 @@ private SyntaxNode SimplifyDefaultExpression(
                 CancellationToken cancellationToken)
             {
                 if (optionSet.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Value &&
-                    ParseOptions.LanguageVersion >= LanguageVersion.CSharp7_1 &&
-                    node.CanReplaceWithDefaultLiteral(semanticModel, cancellationToken))
+                    node.CanReplaceWithDefaultLiteral(ParseOptions, semanticModel, cancellationToken))
                 {
                     return SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
                                         .WithTriviaFrom(node);

From 5af03dc7efc45501ba5c07f61cfdd745d9e91d1b Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 02:30:00 -0700
Subject: [PATCH 217/284] Move all option checking to a single location.

---
 .../CSharpUseDefaultLiteralCodeFixProvider.cs |  4 ++-
 ...harpUseDefaultLiteralDiagnosticAnalyzer.cs | 31 +++++++++----------
 .../DefaultExpressionSyntaxExtensions.cs      |  8 +++++
 ...CSharpDefaultExpressionReducer.Rewriter.cs |  3 +-
 4 files changed, 26 insertions(+), 20 deletions(-)

diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
index 060c9367eb2db..db6f09af6e5db 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
@@ -43,6 +43,8 @@ protected override async Task FixAllAsync(
             // to replace one at a time, and only actually replace if it's still safe to do so.
 
             var parseOptions = (CSharpParseOptions)document.Project.ParseOptions;
+            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+
             var workspace = document.Project.Solution.Workspace;
             var originalRoot = editor.OriginalRoot;
 
@@ -59,7 +61,7 @@ protected override async Task FixAllAsync(
             {
                 var defaultExpression = currentRoot.GetCurrentNode(originalDefaultExpression);
 
-                if (defaultExpression.CanReplaceWithDefaultLiteral(parseOptions, semanticModel, cancellationToken))
+                if (defaultExpression.CanReplaceWithDefaultLiteral(parseOptions, options, semanticModel, cancellationToken))
                 {
                     var replacement = SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
                                                    .WithTriviaFrom(defaultExpression);
diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
index bbf26a9d44483..27ce30677579b 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
@@ -35,35 +35,32 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
             var cancellationToken = context.CancellationToken;
 
             var syntaxTree = context.Node.SyntaxTree;
-            var parseOptions = (CSharpParseOptions)syntaxTree.Options;
-            if (parseOptions.LanguageVersion < LanguageVersion.CSharp7_1)
-            {
-                return;
-            }
-
-            var options = context.Options;
-            var optionSet = options.GetDocumentOptionSetAsync(syntaxTree, cancellationToken).GetAwaiter().GetResult();
+            var optionSet = context.Options.GetDocumentOptionSetAsync(syntaxTree, cancellationToken).GetAwaiter().GetResult();
             if (optionSet == null)
             {
                 return;
             }
 
-            var codeStyleOption = optionSet.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral);
-            if (!codeStyleOption.Value)
-            {
-                return;
-            }
-
+            var parseOptions = (CSharpParseOptions)syntaxTree.Options;
             var defaultExpression = (DefaultExpressionSyntax)context.Node;
-            if (!defaultExpression.CanReplaceWithDefaultLiteral(parseOptions, context.SemanticModel, cancellationToken))
+            if (!defaultExpression.CanReplaceWithDefaultLiteral(parseOptions, optionSet, context.SemanticModel, cancellationToken))
             {
                 return;
             }
 
             var fadeSpan = TextSpan.FromBounds(defaultExpression.OpenParenToken.SpanStart, defaultExpression.CloseParenToken.Span.End);
 
-            context.ReportDiagnostic(Diagnostic.Create(GetDescriptorWithSeverity(codeStyleOption.Notification.Value), defaultExpression.GetLocation()));
-            context.ReportDiagnostic(Diagnostic.Create(UnnecessaryWithoutSuggestionDescriptor, syntaxTree.GetLocation(fadeSpan)));
+            // Create a normal diagnostic that covers the entire default expression.
+            context.ReportDiagnostic(
+                Diagnostic.Create(GetDescriptorWithSeverity(
+                    optionSet.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Notification.Value),
+                    defaultExpression.GetLocation()));
+
+            // Also fade out the part of the default expression from the open paren through 
+            // the close paren.
+            context.ReportDiagnostic(
+                Diagnostic.Create(UnnecessaryWithoutSuggestionDescriptor,
+                syntaxTree.GetLocation(fadeSpan)));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
index 2e9d4f6143067..603b3b3360264 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
@@ -1,8 +1,10 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Utilities;
+using Microsoft.CodeAnalysis.Options;
 
 namespace Microsoft.CodeAnalysis.CSharp.Extensions
 {
@@ -13,9 +15,15 @@ internal static class DefaultExpressionSyntaxExtensions
         public static bool CanReplaceWithDefaultLiteral(
             this DefaultExpressionSyntax defaultExpression,
             CSharpParseOptions parseOptions,
+            OptionSet options,
             SemanticModel semanticModel,
             CancellationToken cancellationToken)
         {
+            if (!options.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Value)
+            {
+                return false;
+            }
+
             if (parseOptions.LanguageVersion < LanguageVersion.CSharp7_1)
             {
                 return false;
diff --git a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
index ab3d528a70edb..cbd08b9db172f 100644
--- a/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Simplification/Reducers/CSharpDefaultExpressionReducer.Rewriter.cs
@@ -28,8 +28,7 @@ private SyntaxNode SimplifyDefaultExpression(
                 OptionSet optionSet,
                 CancellationToken cancellationToken)
             {
-                if (optionSet.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Value &&
-                    node.CanReplaceWithDefaultLiteral(ParseOptions, semanticModel, cancellationToken))
+                if (node.CanReplaceWithDefaultLiteral(ParseOptions, optionSet, semanticModel, cancellationToken))
                 {
                     return SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
                                         .WithTriviaFrom(node);

From 58083acc70ca562cb5f8f5678c17ded612adb0e9 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 02:32:52 -0700
Subject: [PATCH 218/284] Reorder checks.

---
 .../DefaultExpressionSyntaxExtensions.cs      | 22 ++++++++-----------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
index 603b3b3360264..c5bab57c76e11 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
@@ -19,23 +19,19 @@ public static bool CanReplaceWithDefaultLiteral(
             SemanticModel semanticModel,
             CancellationToken cancellationToken)
         {
-            if (!options.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Value)
+            if (parseOptions.LanguageVersion >= LanguageVersion.CSharp7_1 &&
+                options.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Value)
             {
-                return false;
-            }
+                var speculationAnalyzer = new SpeculationAnalyzer(
+                    defaultExpression, s_defaultLiteralExpression, semanticModel,
+                    cancellationToken,
+                    skipVerificationForReplacedNode: true,
+                    failOnOverloadResolutionFailuresInOriginalCode: true);
 
-            if (parseOptions.LanguageVersion < LanguageVersion.CSharp7_1)
-            {
-                return false;
+                return !speculationAnalyzer.ReplacementChangesSemantics();
             }
 
-            var speculationAnalyzer = new SpeculationAnalyzer(
-                defaultExpression, s_defaultLiteralExpression, semanticModel,
-                cancellationToken,
-                skipVerificationForReplacedNode: true,
-                failOnOverloadResolutionFailuresInOriginalCode: true);
-
-            return !speculationAnalyzer.ReplacementChangesSemantics();
+            return false;
         }
     }
 }

From ea26f478243f8b6f1c402fe8b24440cc1d88aab2 Mon Sep 17 00:00:00 2001
From: Jared Parsons <jaredpparsons@gmail.com>
Date: Thu, 11 May 2017 14:14:29 -0500
Subject: [PATCH 219/284] Copying content from WIKI

---
 CONTRIBUTING.md | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 CONTRIBUTING.md

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000000000..e69de29bb2d1d

From 8df2faf8fa650de4aeb71a5985ce4331f03f7ba6 Mon Sep 17 00:00:00 2001
From: Jared Parsons <jaredpparsons@gmail.com>
Date: Thu, 11 May 2017 14:45:17 -0500
Subject: [PATCH 220/284] Meet the intention of CONTRIBUTING.md

The intent of CONTRIBUTING.md is to provide guidelines for contributing to a
repository.  Ours was a mix of guidelines, best practices and developer
workflow.  The other aspects are already covered in our other contributing
documents.

Changing CONTRIBUTING.md to be guideline focused.
---
 CONTRIBUTING.md                               | 63 +++++++++++++++++++
 ...uilding, Debugging, and Testing on Unix.md |  2 +-
 ...ding, Debugging, and Testing on Windows.md |  2 +-
 3 files changed, 65 insertions(+), 2 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e69de29bb2d1d..fd1f915cdcaf7 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -0,0 +1,63 @@
+# Contributing to Roslyn
+
+Guidelines for contributing to the Roslyn repo.
+
+## Submitting Pull Requests
+
+For now, the team has set the following limits on pull requests:
+
+- Contributions beyond the level of a bug fix should be discussed with the team first, or they will likely be declined.
+- Pull requests must pass all Jenkins legs and be merge conflict free before they will be merged. 
+- Submissions must meet functional and performance expectations, including scenarios for which the team doesn’t yet have open source tests. This means you may be asked to fix and resubmit your pull request against a new open test case if it fails one of these tests.
+- Submissions must follow the [.editorconfig](http://editorconfig.org/) settings for each directory. 
+- Contributors must sign the [.NET CLA](https://cla2.dotnetfoundation.org/)
+
+When you are ready to proceed with making a change, get set up to [build](https://github.com/dotnet/roslyn/blob/master/docs/contributing/Building%2C%20Debugging%2C%20and%20Testing%20on%20Windows.md) the code and familiarize yourself with our developer workflow. 
+
+The following types of PRs are not expected by the team and will likely be declined:
+
+- Unsolicited language features: all language feature discussion should begin on the [C# language](https://github.com/dotnet/csharplang#discussion) / [VB language](https://github.com/dotnet/vblang) repos.  Once a feature is championed and validated by LDM a developer will be assigned to help begin a prototype on this repo inside a feature branch.
+- Code formatting changes: PRs which consists soley, or largely, of formatting and style changes.
+
+These two blogs posts on contributing code to open source projects are good too: [Open Source Contribution Etiquette](http://tirania.org/blog/archive/2010/Dec-31.html) by Miguel de Icaza and [Don’t “Push” Your Pull Requests](https://www.igvita.com/2011/12/19/dont-push-your-pull-requests/) by Ilya Grigorik.
+
+## Creating Issues
+
+Please follow these guidelines when creating new issues:
+
+- Use a descriptive title that identifies the issue to be addressed or the requested feature. For example when describing an issue where the compiler is not behaving as expected, write your bug title in terms of what the compiler should do rather than what it is doing – “C# compiler should report CS1234 when Xyz is used in Abcd.”
+- Specify a detailed description of the issue or requested feature.
+- For bug reports, please also:
+    - Describe the expected behavior and the actual behavior. If it is not self-evident such as in the case of a crash, provide an explanation for why the expected behavior is expected.
+    - Provide example code that reproduces the issue.
+    - Specify any relevant exception messages and stack traces.
+- Subscribe to notifications for the created issue in case there are any follow up questions.
+
+## Coding Style
+
+The Roslyn project is a member of the [.NET Foundation](https://github.com/orgs/dotnet) and follow the same [developer guide](https://github.com/dotnet/corefx/blob/master/Documentation/coding-guidelines/coding-style.md).  The repo also includes [.editorconfig](http://editorconfig.org) files to help enforce this convention.  Contributors should ensure they follow these guidelines when making submissions.  
+
+### CSharp
+
+- Use the coding style outlined in the [.NET Foundation Coding Guidelines](https://github.com/dotnet/corefx/blob/master/Documentation/coding-guidelines/coding-style.md)
+- Use plain code to validate parameters at public boundaries. Do not use Contracts or magic helpers.
+
+```csharp
+if (argument == null)
+{
+    throw new ArgumentNullException("argument");
+}
+```
+
+- Use `Debug.Assert()` for checks not needed in retail builds. Always include a “message” string in your assert to identify failure conditions. Add assertions to document assumptions on non-local program state or parameter values, e.g. “At this point in parsing the scanner should have been advanced to a ‘.’ token by the caller”.
+- Avoid allocations in compiler hot paths:
+    - Avoid LINQ.
+    - Avoid using foreach over collections that do not have a struct enumerator.
+    - Consider using an object pool. There are many usages of object pools in the compiler to see an example.
+
+### Visual Basic Conventions
+
+For all of the C# guidelines which have analogs in Visual Basic, the team applies the spirit of the guideline to Visual Basic. Guidelines surrounding spacing, indentation, parameter names, and the use of named parameters are all generally applicable to Visual Basic. ‘Dim’ statements should also follow the guidelines for the use of ‘var’ in C#. Specific to Visual Basic, field names should begin with ‘m_’ or ‘_’. And the team prefers that all field declarations be placed at the beginning of a type definition. The Visual Studio members dropdown does not show fields in VB. Having them at the beginning of the type aids in navigation.
+
+### Tips 'n' Tricks
+Our team finds using [this enhanced source view](http://source.roslyn.io/) of Roslyn helpful when developing.
\ No newline at end of file
diff --git a/docs/contributing/Building, Debugging, and Testing on Unix.md b/docs/contributing/Building, Debugging, and Testing on Unix.md
index 1ea526cdcc90e..cb2b21c691309 100644
--- a/docs/contributing/Building, Debugging, and Testing on Unix.md	
+++ b/docs/contributing/Building, Debugging, and Testing on Unix.md	
@@ -10,4 +10,4 @@ After building run `make test` in order to run the unit tests.
 
 # Contributing
 
-Please see [Contributing Code](https://github.com/dotnet/roslyn/wiki/Contributing-Code) for details on contributing changes back to the code.
+Please see [Contributing Code](https://github.com/dotnet/roslyn/blob/master/CONTRIBUTING.md) for details on contributing changes back to the code.
diff --git a/docs/contributing/Building, Debugging, and Testing on Windows.md b/docs/contributing/Building, Debugging, and Testing on Windows.md
index 14b8af173cd45..0148f02cb3386 100644
--- a/docs/contributing/Building, Debugging, and Testing on Windows.md	
+++ b/docs/contributing/Building, Debugging, and Testing on Windows.md	
@@ -119,4 +119,4 @@ csc and vbc inside it. You can check the cibuild.cmd and see how it is used.
 
 ## Contributing
 
-Please see [Contributing Code](https://github.com/dotnet/roslyn/wiki/Contributing-Code) for details on contributing changes back to the code.
+Please see [Contributing Code](https://github.com/dotnet/roslyn/blob/master/CONTRIBUTING.md)) for details on contributing changes back to the code.

From bf7aaaf4bef16d4fb0c8a196d84733b80f130f29 Mon Sep 17 00:00:00 2001
From: Jared Parsons <jaredpparsons@gmail.com>
Date: Fri, 12 May 2017 05:58:23 -0500
Subject: [PATCH 221/284] Switch to DO / DO NOT style

---
 CONTRIBUTING.md | 43 ++++++++++++++++++-------------------------
 1 file changed, 18 insertions(+), 25 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index fd1f915cdcaf7..07354ce197e6f 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,34 +4,26 @@ Guidelines for contributing to the Roslyn repo.
 
 ## Submitting Pull Requests
 
-For now, the team has set the following limits on pull requests:
-
-- Contributions beyond the level of a bug fix should be discussed with the team first, or they will likely be declined.
-- Pull requests must pass all Jenkins legs and be merge conflict free before they will be merged. 
-- Submissions must meet functional and performance expectations, including scenarios for which the team doesn’t yet have open source tests. This means you may be asked to fix and resubmit your pull request against a new open test case if it fails one of these tests.
-- Submissions must follow the [.editorconfig](http://editorconfig.org/) settings for each directory. 
-- Contributors must sign the [.NET CLA](https://cla2.dotnetfoundation.org/)
+- **DO** ensure submissions pass all Jenkins legs and are merge conflict free.
+- **DO** follow the [.editorconfig](http://editorconfig.org/) settings for each directory. 
+- **DO** submit language feature requests as issues in the [C# language](https://github.com/dotnet/csharplang#discussion) / [VB language](https://github.com/dotnet/vblang) repos.  Once a feature is championed and validated by LDM a developer will be assigned to help begin a prototype on this repo inside a feature branch.
+- **DO NOT** submit language features as PRs to this repo first, or they will likely be declined.
+- **DO** submit issues for other features. This facilitates discussion of a feature separately from its implementation, and increases the acceptance rates for pull requests.
+- **DO NOT** submit large code formatting changes without discussing with the team first.
 
 When you are ready to proceed with making a change, get set up to [build](https://github.com/dotnet/roslyn/blob/master/docs/contributing/Building%2C%20Debugging%2C%20and%20Testing%20on%20Windows.md) the code and familiarize yourself with our developer workflow. 
 
-The following types of PRs are not expected by the team and will likely be declined:
-
-- Unsolicited language features: all language feature discussion should begin on the [C# language](https://github.com/dotnet/csharplang#discussion) / [VB language](https://github.com/dotnet/vblang) repos.  Once a feature is championed and validated by LDM a developer will be assigned to help begin a prototype on this repo inside a feature branch.
-- Code formatting changes: PRs which consists soley, or largely, of formatting and style changes.
-
 These two blogs posts on contributing code to open source projects are good too: [Open Source Contribution Etiquette](http://tirania.org/blog/archive/2010/Dec-31.html) by Miguel de Icaza and [Don’t “Push” Your Pull Requests](https://www.igvita.com/2011/12/19/dont-push-your-pull-requests/) by Ilya Grigorik.
 
 ## Creating Issues
 
-Please follow these guidelines when creating new issues:
-
-- Use a descriptive title that identifies the issue to be addressed or the requested feature. For example when describing an issue where the compiler is not behaving as expected, write your bug title in terms of what the compiler should do rather than what it is doing – “C# compiler should report CS1234 when Xyz is used in Abcd.”
-- Specify a detailed description of the issue or requested feature.
-- For bug reports, please also:
+- **DO** use a descriptive title that identifies the issue to be addressed or the requested feature. For example when describing an issue where the compiler is not behaving as expected, write your bug title in terms of what the compiler should do rather than what it is doing – “C# compiler should report CS1234 when Xyz is used in Abcd.”
+- **DO** specify a detailed description of the issue or requested feature.
+- **DO** provide the following for bug reports
     - Describe the expected behavior and the actual behavior. If it is not self-evident such as in the case of a crash, provide an explanation for why the expected behavior is expected.
     - Provide example code that reproduces the issue.
     - Specify any relevant exception messages and stack traces.
-- Subscribe to notifications for the created issue in case there are any follow up questions.
+- **DO** subscribe to notifications for the created issue in case there are any follow up questions.
 
 ## Coding Style
 
@@ -39,25 +31,26 @@ The Roslyn project is a member of the [.NET Foundation](https://github.com/orgs/
 
 ### CSharp
 
-- Use the coding style outlined in the [.NET Foundation Coding Guidelines](https://github.com/dotnet/corefx/blob/master/Documentation/coding-guidelines/coding-style.md)
-- Use plain code to validate parameters at public boundaries. Do not use Contracts or magic helpers.
+- **DO** use the coding style outlined in the [.NET Foundation Coding Guidelines](https://github.com/dotnet/corefx/blob/master/Documentation/coding-guidelines/coding-style.md)
+- **DO** use plain code to validate parameters at public boundaries. Do not use Contracts or magic helpers.
 
 ```csharp
 if (argument == null)
 {
-    throw new ArgumentNullException("argument");
+    throw new ArgumentNullException(nameof(argument));
 }
 ```
 
-- Use `Debug.Assert()` for checks not needed in retail builds. Always include a “message” string in your assert to identify failure conditions. Add assertions to document assumptions on non-local program state or parameter values, e.g. “At this point in parsing the scanner should have been advanced to a ‘.’ token by the caller”.
-- Avoid allocations in compiler hot paths:
+- **DO** use `Debug.Assert()` for checks not needed in retail builds. Always include a “message” string in your assert to identify failure conditions. Add assertions to document assumptions on non-local program state or parameter values, e.g. “At this point in parsing the scanner should have been advanced to a ‘.’ token by the caller”.
+- **DO** avoid allocations in compiler hot paths:
     - Avoid LINQ.
-    - Avoid using foreach over collections that do not have a struct enumerator.
+    - Avoid using `foreach` over collections that do not have a `struct` enumerator.
     - Consider using an object pool. There are many usages of object pools in the compiler to see an example.
 
 ### Visual Basic Conventions
 
-For all of the C# guidelines which have analogs in Visual Basic, the team applies the spirit of the guideline to Visual Basic. Guidelines surrounding spacing, indentation, parameter names, and the use of named parameters are all generally applicable to Visual Basic. ‘Dim’ statements should also follow the guidelines for the use of ‘var’ in C#. Specific to Visual Basic, field names should begin with ‘m_’ or ‘_’. And the team prefers that all field declarations be placed at the beginning of a type definition. The Visual Studio members dropdown does not show fields in VB. Having them at the beginning of the type aids in navigation.
+- **DO** apply the spirit of C# guidelines to Visual Basic when there are natural analogs. 
+- **DO** place all field declarations at the beginning of a type definition
 
 ### Tips 'n' Tricks
 Our team finds using [this enhanced source view](http://source.roslyn.io/) of Roslyn helpful when developing.
\ No newline at end of file

From ef0f510b4dd81ca200da102c3853afaf0a69c591 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 12:03:03 -0700
Subject: [PATCH 222/284] FOrmatting.

---
 .../CSharpUseDefaultLiteralDiagnosticAnalyzer.cs             | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
index 27ce30677579b..377337f1209e3 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
@@ -59,8 +59,9 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
             // Also fade out the part of the default expression from the open paren through 
             // the close paren.
             context.ReportDiagnostic(
-                Diagnostic.Create(UnnecessaryWithoutSuggestionDescriptor,
-                syntaxTree.GetLocation(fadeSpan)));
+                Diagnostic.Create(
+                    UnnecessaryWithoutSuggestionDescriptor,
+                    syntaxTree.GetLocation(fadeSpan)));
         }
     }
 }
\ No newline at end of file

From 298e3b166a8c6eceead775c7074d2e8720584409 Mon Sep 17 00:00:00 2001
From: Alireza Habibi <habibi.alireza@outlook.com>
Date: Mon, 15 May 2017 21:53:46 +0430
Subject: [PATCH 223/284] PR feedback

---
 .../AbstractConvertNumericLiteralCodeRefactoringProvider.cs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs
index 7e6322a47b9c5..2523086ae0437 100644
--- a/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs
@@ -34,6 +34,12 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex
                 return;
             }
 
+            if (context.Span.Length > 0 && 
+                context.Span != numericToken.Span)
+            {
+                return;
+            }
+
             var syntaxNode = numericToken.Parent;
             var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var symbol = semanticModel.GetTypeInfo(syntaxNode, cancellationToken).Type;

From 0efcbc560eefe244cb2186dd637bb8bd0a0dbc61 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 12:17:50 -0700
Subject: [PATCH 224/284] Add fast paths for analysis.

---
 .../DefaultExpressionSyntaxExtensions.cs      | 76 ++++++++++++++++---
 1 file changed, 66 insertions(+), 10 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
index c5bab57c76e11..2c406e501bea6 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -19,19 +20,74 @@ public static bool CanReplaceWithDefaultLiteral(
             SemanticModel semanticModel,
             CancellationToken cancellationToken)
         {
-            if (parseOptions.LanguageVersion >= LanguageVersion.CSharp7_1 &&
-                options.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Value)
+            if (parseOptions.LanguageVersion < LanguageVersion.CSharp7_1 ||
+                !options.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Value)
             {
-                var speculationAnalyzer = new SpeculationAnalyzer(
-                    defaultExpression, s_defaultLiteralExpression, semanticModel,
-                    cancellationToken,
-                    skipVerificationForReplacedNode: true,
-                    failOnOverloadResolutionFailuresInOriginalCode: true);
+                return false;
+            }
+
+            // Using the speculation analyzer can be slow.  Check for common cases first before
+            // trying the expensive path.
+            return CanReplaceWithDefaultLiteralFast(defaultExpression, semanticModel, cancellationToken) ??
+                   CanReplaceWithDefaultLiteralSlow(defaultExpression, semanticModel, cancellationToken);
+        }
+
+        private static bool? CanReplaceWithDefaultLiteralFast(DefaultExpressionSyntax defaultExpression, SemanticModel semanticModel, CancellationToken cancellationToken)
+        {
+            if (defaultExpression.IsParentKind(SyntaxKind.EqualsValueClause))
+            {
+                var equalsValueClause = (EqualsValueClauseSyntax)defaultExpression.Parent;
+                var typeSyntax = GetTypeSyntax(equalsValueClause);
+
+                if (typeSyntax != null)
+                {
+                    if (typeSyntax.IsVar)
+                    {
+                        // If we have:   var v = default(CancellationToken);    then we can't simplify this.
+                        return false;
+                    }
+
+                    var entityType = semanticModel.GetTypeInfo(typeSyntax, cancellationToken).Type;
+                    var defaultType = semanticModel.GetTypeInfo(defaultExpression.Type, cancellationToken).Type;
+
+                    if (entityType != null && entityType.Equals(defaultType))
+                    {
+                        // We have a simple case of "CancellationToken c = default(CancellationToken)".
+                        // We can just simplify without having to do any additional analysis.
+                        return true;
+                    }
+                }
+            }
 
-                return !speculationAnalyzer.ReplacementChangesSemantics();
+            return null;
+        }
+
+        private static TypeSyntax GetTypeSyntax(EqualsValueClauseSyntax equalsValueClause)
+        {
+            if (equalsValueClause.IsParentKind(SyntaxKind.VariableDeclarator) &&
+                equalsValueClause.Parent.IsParentKind(SyntaxKind.VariableDeclaration))
+            {
+                var declaration = (VariableDeclarationSyntax)equalsValueClause.Parent.Parent;
+                return declaration.Type;
+            }
+            else if (equalsValueClause.IsParentKind(SyntaxKind.Parameter))
+            {
+                var parameter = (ParameterSyntax)equalsValueClause.Parent;
+                return parameter.Type;
             }
 
-            return false;
+            return null;
+        }
+
+        private static bool CanReplaceWithDefaultLiteralSlow(DefaultExpressionSyntax defaultExpression, SemanticModel semanticModel, CancellationToken cancellationToken)
+        {
+            var speculationAnalyzer = new SpeculationAnalyzer(
+                defaultExpression, s_defaultLiteralExpression, semanticModel,
+                cancellationToken,
+                skipVerificationForReplacedNode: true,
+                failOnOverloadResolutionFailuresInOriginalCode: true);
+
+            return !speculationAnalyzer.ReplacementChangesSemantics();
         }
     }
-}
+}
\ No newline at end of file

From 479f888ee6d012da3af742ff004c6924bb6528b2 Mon Sep 17 00:00:00 2001
From: Alireza Habibi <habibi.alireza@outlook.com>
Date: Mon, 15 May 2017 23:49:47 +0430
Subject: [PATCH 225/284] Add tests

---
 .../ConvertNumericLiteralTests.cs             | 24 +++++++++++++++++++
 .../ConvertNumericLiteralTests.vb             | 19 +++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs
index ae27a69079097..27fc351678361 100644
--- a/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs
+++ b/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs
@@ -136,5 +136,29 @@ await TestInRegularAndScriptAsync(
   int a = 0b101010;
 }", index: (int)Refactoring.ChangeBase1);
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertNumericLiteral)]
+        public async Task TestSelectionMatchesToken()
+        {
+            await TestInRegularAndScriptAsync(
+@"class C
+{
+  int a = [|42|];
+}",
+@"class C
+{
+  int a = 0b101010;
+}", index: (int)Refactoring.ChangeBase1);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertNumericLiteral)]
+        public async Task TestSelectionDoesntMatchToken()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"class C
+{
+  int a = [|42 * 2|];
+}");
+        }
     }
 }
diff --git a/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb b/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb
index c51c551401cad..e4923a3269219 100644
--- a/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.vb
@@ -123,5 +123,24 @@ End Class",
     Dim a As Integer = &B101010
 End Class", index:=Refactoring.ChangeBase1)
         End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertNumericLiteral)>
+        Public Async Function TestSelectionMatchesToken() As Task
+            Await TestInRegularAndScriptAsync(
+"Class C
+    Dim a As Integer = [|42|]
+End Class",
+"Class C
+    Dim a As Integer = &B101010
+End Class", index:=Refactoring.ChangeBase1)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertNumericLiteral)>
+        Public Async Function TestSelectionDoesntMatchToken() As Task
+            Await TestMissingInRegularAndScriptAsync(
+"Class C
+    Dim a As Integer = [|42 * 2|]
+End Class")
+        End Function
     End Class
 End Namespace

From acb122ea4c06fc7f17c526b724290ed1d3ab083a Mon Sep 17 00:00:00 2001
From: Alireza Habibi <habibi.alireza@outlook.com>
Date: Mon, 15 May 2017 23:55:20 +0430
Subject: [PATCH 226/284] Formatting.

---
 .../ConvertNumericLiteralTests.cs                      | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs
index 27fc351678361..9518ab101ed71 100644
--- a/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs
+++ b/src/EditorFeatures/CSharpTest/CodeActions/ConvertNumericLiteral/ConvertNumericLiteralTests.cs
@@ -129,11 +129,11 @@ public async Task TestCaretPositionAtTheEnd()
             await TestInRegularAndScriptAsync(
 @"class C
 {
-  int a = 42[||];
+    int a = 42[||];
 }",
 @"class C
 {
-  int a = 0b101010;
+    int a = 0b101010;
 }", index: (int)Refactoring.ChangeBase1);
         }
 
@@ -143,11 +143,11 @@ public async Task TestSelectionMatchesToken()
             await TestInRegularAndScriptAsync(
 @"class C
 {
-  int a = [|42|];
+    int a = [|42|];
 }",
 @"class C
 {
-  int a = 0b101010;
+    int a = 0b101010;
 }", index: (int)Refactoring.ChangeBase1);
         }
 
@@ -157,7 +157,7 @@ public async Task TestSelectionDoesntMatchToken()
             await TestMissingInRegularAndScriptAsync(
 @"class C
 {
-  int a = [|42 * 2|];
+    int a = [|42 * 2|];
 }");
         }
     }

From 85de1be8b64d0c50d95a494ebd648cc6aafae76b Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 12:40:40 -0700
Subject: [PATCH 227/284] Add tests.

---
 .../UseDefaultLiteralTests.cs                 | 138 ++++++++++++++++++
 .../DefaultExpressionSyntaxExtensions.cs      |   2 +-
 2 files changed, 139 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs b/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs
index f6e2c8a4f71c3..a00b66e0a5152 100644
--- a/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs
+++ b/src/EditorFeatures/CSharpTest/UseDefaultLiteral/UseDefaultLiteralTests.cs
@@ -56,6 +56,106 @@ void Foo(string s = default)
 }", parseOptions: s_parseOptions);
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestInIfCheck()
+        {
+            await TestAsync(
+@"
+class C
+{
+    void Foo(string s)
+    {
+        if (s == [||]default(string)) { }
+    }
+}",
+@"
+class C
+{
+    void Foo(string s)
+    {
+        if (s == default) { }
+    }
+}", parseOptions: s_parseOptions);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestInReturnStatement()
+        {
+            await TestAsync(
+@"
+class C
+{
+    string Foo()
+    {
+        return [||]default(string);
+    }
+}",
+@"
+class C
+{
+    string Foo()
+    {
+        return default;
+    }
+}", parseOptions: s_parseOptions);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestInReturnStatement2()
+        {
+            await TestMissingAsync(
+@"
+class C
+{
+    string Foo()
+    {
+        return [||]default(int);
+    }
+}", parameters: s_testParameters);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestInLambda1()
+        {
+            await TestAsync(
+@"
+using System;
+
+class C
+{
+    void Foo()
+    {
+        Func<string> f = () => [||]default(string);
+    }
+}",
+@"
+using System;
+
+class C
+{
+    void Foo()
+    {
+        Func<string> f = () => [||]default;
+    }
+}", parseOptions: s_parseOptions);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestInLambda2()
+        {
+            await TestMissingAsync(
+@"
+using System;
+
+class C
+{
+    void Foo()
+    {
+        Func<string> f = () => [||]default(int);
+    }
+}", parameters: s_testParameters);
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
         public async Task TestInLocalInitializer()
         {
@@ -78,6 +178,20 @@ void Foo()
 }", parseOptions: s_parseOptions);
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestInLocalInitializer2()
+        {
+            await TestMissingAsync(
+@"
+class C
+{
+    void Foo()
+    {
+        string s = [||]default(int);
+    }
+}", parameters: s_testParameters);
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
         public async Task TestNotForVar()
         {
@@ -222,6 +336,30 @@ void Foo(bool b)
     {
         string s1 = b ? default : default(string);
     }
+}", parseOptions: s_parseOptions);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
+        public async Task TestFixAll3()
+        {
+            await TestAsync(
+@"
+class C
+{
+    void Foo()
+    {
+        string s1 = {|FixAllInDocument:default|}(string);
+        string s2 = default(int);
+    }
+}",
+@"
+class C
+{
+    void Foo()
+    {
+        string s1 = default;
+        string s2 = default(int);
+    }
 }", parseOptions: s_parseOptions);
         }
     }
diff --git a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
index 2c406e501bea6..5b95f532ce06d 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
@@ -84,7 +84,7 @@ private static bool CanReplaceWithDefaultLiteralSlow(DefaultExpressionSyntax def
             var speculationAnalyzer = new SpeculationAnalyzer(
                 defaultExpression, s_defaultLiteralExpression, semanticModel,
                 cancellationToken,
-                skipVerificationForReplacedNode: true,
+                skipVerificationForReplacedNode: false,
                 failOnOverloadResolutionFailuresInOriginalCode: true);
 
             return !speculationAnalyzer.ReplacementChangesSemantics();

From a3124a7cfdd3c403d1674546648b2fa397542326 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 13:01:07 -0700
Subject: [PATCH 228/284] Present feature to user as 'simplify default
 expression'.

---
 .../CSharpUseDefaultLiteralCodeFixProvider.cs |  2 +-
 ...harpUseDefaultLiteralDiagnosticAnalyzer.cs |  8 +++---
 .../Portable/FeaturesResources.Designer.cs    | 27 ++++++++++++-------
 .../Core/Portable/FeaturesResources.resx      |  7 +++--
 .../Impl/Options/Formatting/StyleViewModel.cs |  4 +--
 .../Core/Def/ServicesVSResources.Designer.cs  | 18 ++++++-------
 .../Core/Def/ServicesVSResources.resx         |  4 +--
 .../CodeStyle/CSharpCodeStyleOptions.cs       | 10 +++----
 .../DefaultExpressionSyntaxExtensions.cs      |  2 +-
 9 files changed, 46 insertions(+), 36 deletions(-)

diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
index db6f09af6e5db..b5b2143ed6283 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
@@ -79,7 +79,7 @@ protected override async Task FixAllAsync(
         private class MyCodeAction : CodeAction.DocumentChangeAction
         {
             public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
-                : base(FeaturesResources.Use_default_literal, createChangedDocument)
+                : base(FeaturesResources.Simplify_default_expression, createChangedDocument)
             {
             }
         }
diff --git a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
index 377337f1209e3..d0c383483311a 100644
--- a/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/UseDefaultLiteral/CSharpUseDefaultLiteralDiagnosticAnalyzer.cs
@@ -1,11 +1,9 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Threading;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.CSharp.Utilities;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;
 
@@ -16,8 +14,8 @@ internal class CSharpUseDefaultLiteralDiagnosticAnalyzer : AbstractCodeStyleDiag
     {
         public CSharpUseDefaultLiteralDiagnosticAnalyzer() 
             : base(IDEDiagnosticIds.UseDefaultLiteralDiagnosticId,
-                   new LocalizableResourceString(
-                       nameof(FeaturesResources.Use_default_literal), FeaturesResources.ResourceManager, typeof(FeaturesResources)))
+                   new LocalizableResourceString(nameof(FeaturesResources.Simplify_default_expression), FeaturesResources.ResourceManager, typeof(FeaturesResources)),
+                   new LocalizableResourceString(nameof(FeaturesResources.default_expression_can_be_simplified), FeaturesResources.ResourceManager, typeof(FeaturesResources)))
         {
         }
 
@@ -53,7 +51,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
             // Create a normal diagnostic that covers the entire default expression.
             context.ReportDiagnostic(
                 Diagnostic.Create(GetDescriptorWithSeverity(
-                    optionSet.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Notification.Value),
+                    optionSet.GetOption(CSharpCodeStyleOptions.PreferSimpleDefaultExpression).Notification.Value),
                     defaultExpression.GetLocation()));
 
             // Also fade out the part of the default expression from the open paren through 
diff --git a/src/Features/Core/Portable/FeaturesResources.Designer.cs b/src/Features/Core/Portable/FeaturesResources.Designer.cs
index 5b136db7f1f69..c85759f7a6ee7 100644
--- a/src/Features/Core/Portable/FeaturesResources.Designer.cs
+++ b/src/Features/Core/Portable/FeaturesResources.Designer.cs
@@ -863,6 +863,15 @@ internal static string Create_and_initialize_property_0 {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to &apos;default&apos; expression can be simplified.
+        /// </summary>
+        internal static string default_expression_can_be_simplified {
+            get {
+                return ResourceManager.GetString("default_expression_can_be_simplified", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to delegate.
         /// </summary>
@@ -2664,6 +2673,15 @@ internal static string Simplify_collection_initialization {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Simplify &apos;default&apos; expression.
+        /// </summary>
+        internal static string Simplify_default_expression {
+            get {
+                return ResourceManager.GetString("Simplify_default_expression", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Simplify Member Access.
         /// </summary>
@@ -3280,15 +3298,6 @@ internal static string Use_coalesce_expression {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Use &apos;default&apos; literal.
-        /// </summary>
-        internal static string Use_default_literal {
-            get {
-                return ResourceManager.GetString("Use_default_literal", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to Use explicitly provided tuple name.
         /// </summary>
diff --git a/src/Features/Core/Portable/FeaturesResources.resx b/src/Features/Core/Portable/FeaturesResources.resx
index 0498a68122edb..e68790cec075d 100644
--- a/src/Features/Core/Portable/FeaturesResources.resx
+++ b/src/Features/Core/Portable/FeaturesResources.resx
@@ -1241,7 +1241,10 @@ This version used in: {2}</value>
   <data name="Implement_0" xml:space="preserve">
     <value>Implement {0}</value>
   </data>
-  <data name="Use_default_literal" xml:space="preserve">
-    <value>Use 'default' literal</value>
+  <data name="Simplify_default_expression" xml:space="preserve">
+    <value>Simplify 'default' expression</value>
+  </data>
+  <data name="default_expression_can_be_simplified" xml:space="preserve">
+    <value>'default' expression can be simplified</value>
   </data>
 </root>
\ No newline at end of file
diff --git a/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs b/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
index f36f1a86e7998..de58425e5615c 100644
--- a/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
@@ -427,7 +427,7 @@ public Customer()
 }}
 ";
 
-        private static readonly string s_preferDefaultLiteral = $@"
+        private static readonly string s_preferSimpleDefaultExpression = $@"
 using System.Threading;
 
 class Customer
@@ -708,7 +708,7 @@ internal StyleViewModel(OptionSet optionSet, IServiceProvider serviceProvider) :
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferPatternMatchingOverIsWithCastCheck, CSharpVSResources.Prefer_pattern_matching_over_is_with_cast_check, s_preferPatternMatchingOverIsWithCastCheck, s_preferPatternMatchingOverIsWithCastCheck, this, optionSet, expressionPreferencesGroupTitle));
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferPatternMatchingOverAsWithNullCheck, CSharpVSResources.Prefer_pattern_matching_over_as_with_null_check, s_preferPatternMatchingOverAsWithNullCheck, s_preferPatternMatchingOverAsWithNullCheck, this, optionSet, expressionPreferencesGroupTitle));
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CodeStyleOptions.PreferExplicitTupleNames, ServicesVSResources.Prefer_explicit_tuple_name, s_preferExplicitTupleName, s_preferExplicitTupleName, this, optionSet, expressionPreferencesGroupTitle));
-            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferDefaultLiteral, ServicesVSResources.Prefer_default_literal, s_preferDefaultLiteral, s_preferDefaultLiteral, this, optionSet, expressionPreferencesGroupTitle));
+            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferSimpleDefaultExpression, ServicesVSResources.Prefer_simple_default_expression, s_preferSimpleDefaultExpression, s_preferSimpleDefaultExpression, this, optionSet, expressionPreferencesGroupTitle));
 
             AddExpressionBodyOptions(optionSet, expressionPreferencesGroupTitle);
 
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs b/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
index e5b777cdf34b8..e42e9d25e747b 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
@@ -1502,15 +1502,6 @@ internal static string Prefer_colon {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Prefer &apos;default&apos; literal.
-        /// </summary>
-        internal static string Prefer_default_literal {
-            get {
-                return ResourceManager.GetString("Prefer_default_literal", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to Prefer explicit tuple name.
         /// </summary>
@@ -1565,6 +1556,15 @@ internal static string Prefer_predefined_type {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Prefer simple &apos;default&apos; expression.
+        /// </summary>
+        internal static string Prefer_simple_default_expression {
+            get {
+                return ResourceManager.GetString("Prefer_simple_default_expression", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to prefer throwing properties.
         /// </summary>
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index 0f2b08b225f0a..e0a430ab5534e 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -912,7 +912,7 @@ Additional information: {1}</value>
   <data name="Options" xml:space="preserve">
     <value>Options</value>
   </data>
-  <data name="Prefer_default_literal" xml:space="preserve">
-    <value>Prefer 'default' literal</value>
+  <data name="Prefer_simple_default_expression" xml:space="preserve">
+    <value>Prefer simple 'default' expression</value>
   </data>
 </root>
\ No newline at end of file
diff --git a/src/Workspaces/CSharp/Portable/CodeStyle/CSharpCodeStyleOptions.cs b/src/Workspaces/CSharp/Portable/CodeStyle/CSharpCodeStyleOptions.cs
index 3348b55b2df2e..4ff203410f64e 100644
--- a/src/Workspaces/CSharp/Portable/CodeStyle/CSharpCodeStyleOptions.cs
+++ b/src/Workspaces/CSharp/Portable/CodeStyle/CSharpCodeStyleOptions.cs
@@ -134,11 +134,11 @@ public static CodeStyleOption<ExpressionBodyPreference> ParseExpressionBodyPrefe
                 EditorConfigStorageLocation.ForBoolCodeStyleOption("csharp_prefer_braces"),
                 new RoamingProfileStorageLocation($"TextEditor.CSharp.Specific.{nameof(PreferBraces)}")});
 
-        public static readonly Option<CodeStyleOption<bool>> PreferDefaultLiteral = new Option<CodeStyleOption<bool>>(
-            nameof(CodeStyleOptions), nameof(PreferDefaultLiteral), defaultValue: CodeStyleOptions.TrueWithSuggestionEnforcement,
+        public static readonly Option<CodeStyleOption<bool>> PreferSimpleDefaultExpression = new Option<CodeStyleOption<bool>>(
+            nameof(CodeStyleOptions), nameof(PreferSimpleDefaultExpression), defaultValue: CodeStyleOptions.TrueWithSuggestionEnforcement,
             storageLocations: new OptionStorageLocation[] {
-                EditorConfigStorageLocation.ForBoolCodeStyleOption("csharp_prefer_default_literal"),
-                new RoamingProfileStorageLocation($"TextEditor.CSharp.Specific.{nameof(PreferDefaultLiteral)}")});
+                EditorConfigStorageLocation.ForBoolCodeStyleOption("csharp_prefer_simple_default_expression"),
+                new RoamingProfileStorageLocation($"TextEditor.CSharp.Specific.{nameof(PreferSimpleDefaultExpression)}")});
 
         public static IEnumerable<Option<CodeStyleOption<bool>>> GetCodeStyleOptions()
         {
@@ -149,7 +149,7 @@ public static IEnumerable<Option<CodeStyleOption<bool>>> GetCodeStyleOptions()
             yield return PreferPatternMatchingOverAsWithNullCheck;
             yield return PreferPatternMatchingOverIsWithCastCheck;
             yield return PreferBraces;
-            yield return PreferDefaultLiteral;
+            yield return PreferSimpleDefaultExpression;
         }
 
         public static IEnumerable<Option<CodeStyleOption<ExpressionBodyPreference>>> GetExpressionBodyOptions()
diff --git a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
index 5b95f532ce06d..45d867dbe7527 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/DefaultExpressionSyntaxExtensions.cs
@@ -21,7 +21,7 @@ public static bool CanReplaceWithDefaultLiteral(
             CancellationToken cancellationToken)
         {
             if (parseOptions.LanguageVersion < LanguageVersion.CSharp7_1 ||
-                !options.GetOption(CSharpCodeStyleOptions.PreferDefaultLiteral).Value)
+                !options.GetOption(CSharpCodeStyleOptions.PreferSimpleDefaultExpression).Value)
             {
                 return false;
             }

From d483954d8844efaa6ff4dc47775f700ce50ed917 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Thu, 11 May 2017 15:53:03 -0700
Subject: [PATCH 229/284] Remove reference to TestBase from CompilationVerifier

---
 .../Test/Emit/CSharpCompilerEmitTest.csproj   |  3 +-
 .../{EmitMetadata.cs => EmitMetadataTests.cs} |  0
 .../CSharp/Test/Emit/Emit/OutputStreams.cs    | 23 --------
 .../Test/Symbol/Symbols/Source/FieldTests.cs  |  2 +-
 .../Utilities/CSharp/BasicCompilationUtils.cs |  5 --
 .../Test/Utilities/CSharp/CSharpTestBase.cs   | 23 --------
 .../Utilities/VisualBasic/BasicTestBase.vb    | 14 -----
 .../Symbol/SymbolsTests/Source/FieldTests.vb  |  2 +-
 .../CommonTestBase.CompilationVerifier.cs     | 57 +++++++++++--------
 src/Test/Utilities/Portable/CommonTestBase.cs |  6 +-
 10 files changed, 36 insertions(+), 99 deletions(-)
 rename src/Compilers/CSharp/Test/Emit/Emit/{EmitMetadata.cs => EmitMetadataTests.cs} (100%)
 delete mode 100644 src/Compilers/CSharp/Test/Emit/Emit/OutputStreams.cs

diff --git a/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj b/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj
index 92f79c80837b7..e4d06c7c65ba6 100644
--- a/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj
+++ b/src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj
@@ -146,14 +146,13 @@
     <Compile Include="Emit\EditAndContinue\LocalSlotMappingTests.cs" />
     <Compile Include="Emit\EmitCustomModifiers.cs" />
     <Compile Include="Emit\EmitErrorTests.cs" />
-    <Compile Include="Emit\EmitMetadata.cs" />
+    <Compile Include="Emit\EmitMetadataTests.cs" />
     <Compile Include="Emit\EmitMetadataTestBase.cs" />
     <Compile Include="Attributes\EmitTestStrongNameProvider.cs" />
     <Compile Include="Emit\EndToEndTests.cs" />
     <Compile Include="Emit\EntryPointTests.cs" />
     <Compile Include="Emit\NoPiaEmbedTypes.cs" />
     <Compile Include="Emit\OptionalArgumentsTests.cs" />
-    <Compile Include="Emit\OutputStreams.cs" />
     <Compile Include="Emit\ResourceTests.cs" />
     <Compile Include="CodeGen\CodeGenScriptTests.cs" />
     <Compile Include="PDB\CheckSumTest.cs" />
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EmitMetadata.cs b/src/Compilers/CSharp/Test/Emit/Emit/EmitMetadataTests.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Emit/EmitMetadata.cs
rename to src/Compilers/CSharp/Test/Emit/Emit/EmitMetadataTests.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/OutputStreams.cs b/src/Compilers/CSharp/Test/Emit/Emit/OutputStreams.cs
deleted file mode 100644
index 674fd11abe81b..0000000000000
--- a/src/Compilers/CSharp/Test/Emit/Emit/OutputStreams.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System;
-using System.IO;
-using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
-
-namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Emit
-{
-    internal class NameResolver
-    {
-        public string GetDebugInformationFileName(SyntaxTree syntaxTree)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Stream GetXmlInclude(SyntaxTree syntaxTree, string xmlIncludeFile)
-        {
-            throw new NotImplementedException();
-        }
-    }
-}
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FieldTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FieldTests.cs
index e729fb6704689..47674b58aca6a 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FieldTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/FieldTests.cs
@@ -483,7 +483,7 @@ static System.Action<object> F()
                 Diagnostic(ErrorCode.WRN_UnreferencedFieldAssg, "value__").WithArguments("A.value__"));
 
             // PEVerify should not report "Field value__ ... is not marked RTSpecialName".
-            var verifier = new CompilationVerifier(this, compilation);
+            var verifier = new CompilationVerifier(compilation);
             verifier.EmitAndVerify(
                 "Error: Field name value__ is reserved for Enums only.",
                 "Error: Field name value__ is reserved for Enums only.",
diff --git a/src/Compilers/Test/Utilities/CSharp/BasicCompilationUtils.cs b/src/Compilers/Test/Utilities/CSharp/BasicCompilationUtils.cs
index faa5e71bbc9b7..8bce514d5e182 100644
--- a/src/Compilers/Test/Utilities/CSharp/BasicCompilationUtils.cs
+++ b/src/Compilers/Test/Utilities/CSharp/BasicCompilationUtils.cs
@@ -53,11 +53,6 @@ protected override Compilation GetCompilationForEmit(IEnumerable<string> source,
                 throw new NotImplementedException();
             }
 
-            internal override IEnumerable<IModuleSymbol> ReferencesToModuleSymbols(IEnumerable<MetadataReference> references, MetadataImportOptions importOptions = MetadataImportOptions.Public)
-            {
-                throw new NotImplementedException();
-            }
-
             internal override string VisualizeRealIL(IModuleSymbol peModule, CodeAnalysis.CodeGen.CompilationTestData.MethodData methodData, IReadOnlyDictionary<int, string> markers)
             {
                 throw new NotImplementedException();
diff --git a/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs b/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
index 917788c4d65bb..114f877c44bbd 100644
--- a/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
@@ -38,11 +38,6 @@ protected CSharpCompilation GetCSharpCompilationForEmit(
             return (CSharpCompilation)base.GetCompilationForEmit(source, additionalRefs, options, parseOptions);
         }
 
-        internal new IEnumerable<ModuleSymbol> ReferencesToModuleSymbols(IEnumerable<MetadataReference> references, MetadataImportOptions importOptions = MetadataImportOptions.Public)
-        {
-            return base.ReferencesToModuleSymbols(references, importOptions).Cast<ModuleSymbol>();
-        }
-
         private Action<IModuleSymbol> Translate2(Action<ModuleSymbol> action)
         {
             if (action != null)
@@ -219,24 +214,6 @@ public static CSharpCompilation CreateWinRtCompilation(string text, MetadataRefe
                                                     TestOptions.ReleaseExe);
         }
 
-        internal override IEnumerable<IModuleSymbol> ReferencesToModuleSymbols(IEnumerable<MetadataReference> references, MetadataImportOptions importOptions = MetadataImportOptions.Public)
-        {
-            var options = TestOptions.ReleaseDll.WithMetadataImportOptions(importOptions);
-            var tc1 = CSharpCompilation.Create("Dummy", new SyntaxTree[0], references, options);
-            return references.Select(r =>
-            {
-                if (r.Properties.Kind == MetadataImageKind.Assembly)
-                {
-                    var assemblySymbol = tc1.GetReferencedAssemblySymbol(r);
-                    return (object)assemblySymbol == null ? null : assemblySymbol.Modules[0];
-                }
-                else
-                {
-                    return tc1.GetReferencedModuleSymbol(r);
-                }
-            });
-        }
-
         protected override CompilationOptions CompilationOptionsReleaseDll
         {
             get { return TestOptions.ReleaseDll; }
diff --git a/src/Compilers/Test/Utilities/VisualBasic/BasicTestBase.vb b/src/Compilers/Test/Utilities/VisualBasic/BasicTestBase.vb
index 1f2063c4ad3bc..795ccfcfe58b2 100644
--- a/src/Compilers/Test/Utilities/VisualBasic/BasicTestBase.vb
+++ b/src/Compilers/Test/Utilities/VisualBasic/BasicTestBase.vb
@@ -414,20 +414,6 @@ End Class
 Public MustInherit Class BasicTestBaseBase
     Inherits CommonTestBase
 
-    Friend Overrides Function ReferencesToModuleSymbols(references As IEnumerable(Of MetadataReference), Optional importOptions As MetadataImportOptions = MetadataImportOptions.Public) As IEnumerable(Of IModuleSymbol)
-        Dim options = DirectCast(CompilationOptionsReleaseDll, VisualBasicCompilationOptions).WithMetadataImportOptions(importOptions)
-        Dim tc1 = VisualBasicCompilation.Create("Dummy", references:=references, options:=options)
-        Return references.Select(
-            Function(r)
-                If r.Properties.Kind = MetadataImageKind.Assembly Then
-                    Dim assemblySymbol = tc1.GetReferencedAssemblySymbol(r)
-                    Return If(assemblySymbol Is Nothing, Nothing, assemblySymbol.Modules(0))
-                Else
-                    Return tc1.GetReferencedModuleSymbol(r)
-                End If
-            End Function)
-    End Function
-
     Protected Overrides ReadOnly Property CompilationOptionsReleaseDll As CompilationOptions
         Get
             Return TestOptions.ReleaseDll
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/FieldTests.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/FieldTests.vb
index d445b591d980f..436de03b2743e 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/FieldTests.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/FieldTests.vb
@@ -491,7 +491,7 @@ End Module
             compilation.AssertNoErrors()
 
             ' PEVerify should not report "Field value__ ... is not marked RTSpecialName".
-            Dim verifier = New CompilationVerifier(Me, compilation)
+            Dim verifier = New CompilationVerifier(compilation)
             verifier.EmitAndVerify(
                 "Error: Field name value__ is reserved for Enums only.")
         End Sub
diff --git a/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs b/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs
index 5b2df8ca3df4f..0a15afaad15d6 100644
--- a/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs
+++ b/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs
@@ -25,7 +25,6 @@ public partial class CommonTestBase
     {
         public class CompilationVerifier
         {
-            private readonly CommonTestBase _test;
             private readonly Compilation _compilation;
             private CompilationTestData _testData;
             private readonly IEnumerable<ModuleData> _dependencies;
@@ -36,35 +35,21 @@ public class CompilationVerifier
             internal ImmutableArray<byte> EmittedAssemblyData;
             internal ImmutableArray<byte> EmittedAssemblyPdb;
 
-            public CompilationVerifier(
-                CommonTestBase test,
+            private readonly Func<IModuleSymbol, CompilationTestData.MethodData, IReadOnlyDictionary<int, string>, string> _visualizeRealIL;
+
+            internal CompilationVerifier(
                 Compilation compilation,
+                Func<IModuleSymbol, CompilationTestData.MethodData, IReadOnlyDictionary<int, string>, string> visualizeRealIL = null,
                 IEnumerable<ModuleData> dependencies = null)
             {
-                _test = test;
                 _compilation = compilation;
                 _dependencies = dependencies;
+                _visualizeRealIL = visualizeRealIL;
             }
 
-            internal CompilationTestData TestData
-            {
-                get { return _testData; }
-            }
-
-            public Compilation Compilation
-            {
-                get { return _compilation; }
-            }
-
-            public TempRoot Temp
-            {
-                get { return _test.Temp; }
-            }
-
-            internal ImmutableArray<Diagnostic> Diagnostics
-            {
-                get { return _diagnostics; }
-            }
+            internal CompilationTestData TestData => _testData;
+            public Compilation Compilation => _compilation;
+            internal ImmutableArray<Diagnostic> Diagnostics => _diagnostics;
 
             internal ImmutableArray<ModuleMetadata> GetAllModuleMetadata()
             {
@@ -283,7 +268,7 @@ internal string VisualizeIL(CompilationTestData.MethodData methodData, bool real
                     _lazyModuleSymbol = GetModuleSymbolForEmittedImage(EmittedAssemblyData, MetadataImportOptions.All);
                 }
 
-                return _lazyModuleSymbol != null ? _test.VisualizeRealIL(_lazyModuleSymbol, methodData, markers) : null;
+                return _lazyModuleSymbol != null ? _visualizeRealIL(_lazyModuleSymbol, methodData, markers) : null;
             }
 
             public CompilationVerifier VerifyMemberInIL(string methodName, bool expected)
@@ -312,10 +297,32 @@ private IModuleSymbol GetModuleSymbolForEmittedImage(ImmutableArray<byte> peImag
 
                 var targetReference = LoadTestEmittedExecutableForSymbolValidation(peImage, _compilation.Options.OutputKind, display: _compilation.AssemblyName);
                 var references = _compilation.References.Concat(new[] { targetReference });
-                var assemblies = _test.ReferencesToModuleSymbols(references, importOptions);
+                var assemblies = GetReferencesToModuleSymbols(references, importOptions);
                 return assemblies.Last();
             }
 
+            private IEnumerable<IModuleSymbol> GetReferencesToModuleSymbols(IEnumerable<MetadataReference> references, MetadataImportOptions importOptions)
+            {
+                var dummy = _compilation
+                    .RemoveAllReferences()
+                    .RemoveAllSyntaxTrees()
+                    .WithReferences(references)
+                    .WithAssemblyName("Dummy")
+                    .WithOptions(_compilation.Options.WithMetadataImportOptions(importOptions));
+
+                return references.Select(reference =>
+                {
+                    if (reference.Properties.Kind == MetadataImageKind.Assembly)
+                    {
+                        return ((IAssemblySymbol)dummy.GetAssemblyOrModuleSymbol(reference))?.Modules.First();
+                    }
+                    else
+                    {
+                        return (IModuleSymbol)dummy.GetAssemblyOrModuleSymbol(reference);
+                    }
+                });
+            }
+
             internal static MetadataReference LoadTestEmittedExecutableForSymbolValidation(
                 ImmutableArray<byte> image,
                 OutputKind outputKind,
diff --git a/src/Test/Utilities/Portable/CommonTestBase.cs b/src/Test/Utilities/Portable/CommonTestBase.cs
index d1adacc3af754..d32b9e4b2b12e 100644
--- a/src/Test/Utilities/Portable/CommonTestBase.cs
+++ b/src/Test/Utilities/Portable/CommonTestBase.cs
@@ -23,8 +23,6 @@ namespace Microsoft.CodeAnalysis.Test.Utilities
     /// </summary>
     public abstract partial class CommonTestBase : TestBase
     {
-        internal abstract IEnumerable<IModuleSymbol> ReferencesToModuleSymbols(IEnumerable<MetadataReference> references, MetadataImportOptions importOptions = MetadataImportOptions.Public);
-
         #region Emit
 
         protected abstract Compilation GetCompilationForEmit(
@@ -214,9 +212,7 @@ internal CompilationVerifier Emit(
             EmitOptions emitOptions,
             bool verify)
         {
-            CompilationVerifier verifier = null;
-
-            verifier = new CompilationVerifier(this, compilation, dependencies);
+            var verifier = new CompilationVerifier(compilation, VisualizeRealIL, dependencies);
 
             verifier.Emit(expectedOutput, expectedReturnCode, args, manifestResources, emitOptions, verify, expectedSignatures);
 

From 83b213bfee8edf005775ca3ccb514e4b6871ceb5 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Thu, 11 May 2017 16:16:54 -0700
Subject: [PATCH 230/284] Unnest CompilationVerifier

---
 .../Emit/CodeGen/CodeGenLocalFunctionTests.cs |   2 +-
 .../CSharp/Test/Emit/CodeGen/GotoTest.cs      |   9 +-
 src/Compilers/CSharp/Test/WinRT/WinRTUtil.cs  |   9 +-
 .../CommonTestBase.CompilationVerifier.cs     | 526 +++++++++---------
 4 files changed, 264 insertions(+), 282 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLocalFunctionTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLocalFunctionTests.cs
index 75a50e471aa80..a8f09509a607a 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLocalFunctionTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLocalFunctionTests.cs
@@ -9,7 +9,7 @@ namespace Microsoft.CodeAnalysis.CSharp.UnitTests.CodeGen
 {
     public static class LocalFunctionTestsUtil
     {
-        public static IMethodSymbol FindLocalFunction(this CommonTestBase.CompilationVerifier verifier, string localFunctionName)
+        public static IMethodSymbol FindLocalFunction(this CompilationVerifier verifier, string localFunctionName)
         {
             localFunctionName = (char)GeneratedNameKind.LocalFunction + "__" + localFunctionName;
             var methods = verifier.TestData.GetMethodsByName();
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/GotoTest.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/GotoTest.cs
index 146fddc1aa862..284bf20c025c6 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/GotoTest.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/GotoTest.cs
@@ -2,6 +2,7 @@
 
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Xunit;
@@ -703,14 +704,6 @@ public static IEnumerable Power(int number, int exponent)
             CompileAndVerify(text, expectedOutput: expectedOutput);
         }
 
-        // When ReflectionEmit supports writing exception handler info, this method
-        // can be removed and CompileAndVerify references above will resolve to
-        // the overload that emits with both CCI and ReflectionEmit. (Bug #7012)
-        private CompilationVerifier CompileAndVerify(string source, string expectedOutput = null)
-        {
-            return base.CompileAndVerify(source: source, expectedOutput: expectedOutput);
-        }
-
         [WorkItem(540719, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/540719")]
         [Fact]
         public void LabelBetweenLocalAndInitialize()
diff --git a/src/Compilers/CSharp/Test/WinRT/WinRTUtil.cs b/src/Compilers/CSharp/Test/WinRT/WinRTUtil.cs
index 9fa0ac76ee32d..27b1e5e0cddf0 100644
--- a/src/Compilers/CSharp/Test/WinRT/WinRTUtil.cs
+++ b/src/Compilers/CSharp/Test/WinRT/WinRTUtil.cs
@@ -1,11 +1,8 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
-using static Microsoft.CodeAnalysis.Test.Utilities.CommonTestBase;
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
diff --git a/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs b/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs
index 0a15afaad15d6..b38100c8d7c75 100644
--- a/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs
+++ b/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs
@@ -3,11 +3,8 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Reflection.Metadata;
-using System.Reflection.Metadata.Ecma335;
 using System.Runtime.CompilerServices;
 using System.Xml.Linq;
 using Microsoft.CodeAnalysis;
@@ -21,335 +18,330 @@
 
 namespace Microsoft.CodeAnalysis.Test.Utilities
 {
-    public partial class CommonTestBase
+    public sealed class CompilationVerifier
     {
-        public class CompilationVerifier
+        private readonly Compilation _compilation;
+        private CompilationTestData _testData;
+        private readonly IEnumerable<ModuleData> _dependencies;
+        private ImmutableArray<Diagnostic> _diagnostics;
+        private IModuleSymbol _lazyModuleSymbol;
+        private IList<ModuleData> _allModuleData;
+
+        internal ImmutableArray<byte> EmittedAssemblyData;
+        internal ImmutableArray<byte> EmittedAssemblyPdb;
+
+        private readonly Func<IModuleSymbol, CompilationTestData.MethodData, IReadOnlyDictionary<int, string>, string> _visualizeRealIL;
+
+        internal CompilationVerifier(
+            Compilation compilation,
+            Func<IModuleSymbol, CompilationTestData.MethodData, IReadOnlyDictionary<int, string>, string> visualizeRealIL = null,
+            IEnumerable<ModuleData> dependencies = null)
         {
-            private readonly Compilation _compilation;
-            private CompilationTestData _testData;
-            private readonly IEnumerable<ModuleData> _dependencies;
-            private ImmutableArray<Diagnostic> _diagnostics;
-            private IModuleSymbol _lazyModuleSymbol;
-            private IList<ModuleData> _allModuleData;
-
-            internal ImmutableArray<byte> EmittedAssemblyData;
-            internal ImmutableArray<byte> EmittedAssemblyPdb;
-
-            private readonly Func<IModuleSymbol, CompilationTestData.MethodData, IReadOnlyDictionary<int, string>, string> _visualizeRealIL;
-
-            internal CompilationVerifier(
-                Compilation compilation,
-                Func<IModuleSymbol, CompilationTestData.MethodData, IReadOnlyDictionary<int, string>, string> visualizeRealIL = null,
-                IEnumerable<ModuleData> dependencies = null)
+            _compilation = compilation;
+            _dependencies = dependencies;
+            _visualizeRealIL = visualizeRealIL;
+        }
+
+        internal CompilationTestData TestData => _testData;
+        public Compilation Compilation => _compilation;
+        internal ImmutableArray<Diagnostic> Diagnostics => _diagnostics;
+
+        internal ImmutableArray<ModuleMetadata> GetAllModuleMetadata()
+        {
+            if (EmittedAssemblyData == null)
             {
-                _compilation = compilation;
-                _dependencies = dependencies;
-                _visualizeRealIL = visualizeRealIL;
+                throw new InvalidOperationException("You must call Emit before calling GetAllModuleMetadata.");
             }
 
-            internal CompilationTestData TestData => _testData;
-            public Compilation Compilation => _compilation;
-            internal ImmutableArray<Diagnostic> Diagnostics => _diagnostics;
+            ImmutableArray<ModuleMetadata> modules = ImmutableArray.Create(ModuleMetadata.CreateFromImage(EmittedAssemblyData));
 
-            internal ImmutableArray<ModuleMetadata> GetAllModuleMetadata()
+            if (_allModuleData != null)
             {
-                if (EmittedAssemblyData == null)
+                var netModules = _allModuleData.Where(m => m.Kind == OutputKind.NetModule);
+                if (netModules.Any())
                 {
-                    throw new InvalidOperationException("You must call Emit before calling GetAllModuleMetadata.");
+                    modules = modules.Concat(
+                        ImmutableArray.CreateRange(netModules.Select(m => ModuleMetadata.CreateFromImage(m.Image))));
                 }
+            }
 
-                ImmutableArray<ModuleMetadata> modules = ImmutableArray.Create(ModuleMetadata.CreateFromImage(EmittedAssemblyData));
+            return modules;
+        }
 
-                if (_allModuleData != null)
+        public void Emit(string expectedOutput, int? expectedReturnCode, string[] args, IEnumerable<ResourceDescription> manifestResources, EmitOptions emitOptions, bool peVerify, SignatureDescription[] expectedSignatures)
+        {
+            using (var testEnvironment = RuntimeEnvironmentFactory.Create(_dependencies))
+            {
+                string mainModuleName = Emit(testEnvironment, manifestResources, emitOptions);
+                _allModuleData = testEnvironment.GetAllModuleData();
+
+                if (peVerify)
                 {
-                    var netModules = _allModuleData.Where(m => m.Kind == OutputKind.NetModule);
-                    if (netModules.Any())
-                    {
-                        modules = modules.Concat(
-                            ImmutableArray.CreateRange(netModules.Select(m => ModuleMetadata.CreateFromImage(m.Image))));
-                    }
+                    testEnvironment.PeVerify();
                 }
 
-                return modules;
-            }
-
-            public void Emit(string expectedOutput, int? expectedReturnCode, string[] args, IEnumerable<ResourceDescription> manifestResources, EmitOptions emitOptions, bool peVerify, SignatureDescription[] expectedSignatures)
-            {
-                using (var testEnvironment = RuntimeEnvironmentFactory.Create(_dependencies))
+                if (expectedSignatures != null)
                 {
-                    string mainModuleName = Emit(testEnvironment, manifestResources, emitOptions);
-                    _allModuleData = testEnvironment.GetAllModuleData();
-
-                    if (peVerify)
-                    {
-                        testEnvironment.PeVerify();
-                    }
+                    MetadataSignatureUnitTestHelper.VerifyMemberSignatures(testEnvironment, expectedSignatures);
+                }
 
-                    if (expectedSignatures != null)
-                    {
-                        MetadataSignatureUnitTestHelper.VerifyMemberSignatures(testEnvironment, expectedSignatures);
-                    }
+                if (expectedOutput != null || expectedReturnCode != null)
+                {
+                    var returnCode = testEnvironment.Execute(mainModuleName, args, expectedOutput);
 
-                    if (expectedOutput != null || expectedReturnCode != null)
+                    if (expectedReturnCode is int exCode)
                     {
-                        var returnCode = testEnvironment.Execute(mainModuleName, args, expectedOutput);
-
-                        if (expectedReturnCode is int exCode)
-                        {
-                            Assert.Equal(exCode, returnCode);
-                        }
+                        Assert.Equal(exCode, returnCode);
                     }
                 }
             }
+        }
 
-            // TODO(tomat): Fold into CompileAndVerify. 
-            // Replace bool verify parameter with string[] expectedPeVerifyOutput. If null, no verification. If empty verify have to succeed. Otherwise compare errors.
-            public void EmitAndVerify(params string[] expectedPeVerifyOutput)
-            {
-                using (var testEnvironment = RuntimeEnvironmentFactory.Create(_dependencies))
-                {
-                    string mainModuleName = Emit(testEnvironment, null, null);
-                    string[] actualOutput = testEnvironment.PeVerifyModules(new[] { mainModuleName }, throwOnError: false);
-                    Assert.Equal(expectedPeVerifyOutput, actualOutput);
-                }
-            }
-
-            private string Emit(IRuntimeEnvironment testEnvironment, IEnumerable<ResourceDescription> manifestResources, EmitOptions emitOptions)
-            {
-                testEnvironment.Emit(_compilation, manifestResources, emitOptions);
-
-                _diagnostics = testEnvironment.GetDiagnostics();
-                EmittedAssemblyData = testEnvironment.GetMainImage();
-                EmittedAssemblyPdb = testEnvironment.GetMainPdb();
-                _testData = ((IInternalRuntimeEnvironment)testEnvironment).GetCompilationTestData();
-
-                return _compilation.Assembly.Identity.GetDisplayName();
-            }
-
-            public CompilationVerifier VerifyIL(
-                string qualifiedMethodName,
-                XCData expectedIL,
-                bool realIL = false,
-                string sequencePoints = null,
-                [CallerFilePath]string callerPath = null,
-                [CallerLineNumber]int callerLine = 0)
+        // TODO(tomat): Fold into CompileAndVerify. 
+        // Replace bool verify parameter with string[] expectedPeVerifyOutput. If null, no verification. If empty verify have to succeed. Otherwise compare errors.
+        public void EmitAndVerify(params string[] expectedPeVerifyOutput)
+        {
+            using (var testEnvironment = RuntimeEnvironmentFactory.Create(_dependencies))
             {
-                return VerifyILImpl(qualifiedMethodName, expectedIL.Value, realIL, sequencePoints, callerPath, callerLine, escapeQuotes: false);
+                string mainModuleName = Emit(testEnvironment, null, null);
+                string[] actualOutput = testEnvironment.PeVerifyModules(new[] { mainModuleName }, throwOnError: false);
+                Assert.Equal(expectedPeVerifyOutput, actualOutput);
             }
+        }
 
-            public CompilationVerifier VerifyIL(
-                string qualifiedMethodName,
-                string expectedIL,
-                bool realIL = false,
-                string sequencePoints = null,
-                [CallerFilePath]string callerPath = null,
-                [CallerLineNumber]int callerLine = 0,
-                string source = null)
-            {
-                return VerifyILImpl(qualifiedMethodName, expectedIL, realIL, sequencePoints, callerPath, callerLine, escapeQuotes: true, source: source);
-            }
+        private string Emit(IRuntimeEnvironment testEnvironment, IEnumerable<ResourceDescription> manifestResources, EmitOptions emitOptions)
+        {
+            testEnvironment.Emit(_compilation, manifestResources, emitOptions);
 
-            public void VerifyLocalSignature(
-                string qualifiedMethodName,
-                string expectedSignature,
-                [CallerLineNumber]int callerLine = 0,
-                [CallerFilePath]string callerPath = null)
-            {
-                var ilBuilder = _testData.GetMethodData(qualifiedMethodName).ILBuilder;
-                string actualSignature = ILBuilderVisualizer.LocalSignatureToString(ilBuilder);
-                AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, actualSignature, escapeQuotes: true, expectedValueSourcePath: callerPath, expectedValueSourceLine: callerLine);
-            }
+            _diagnostics = testEnvironment.GetDiagnostics();
+            EmittedAssemblyData = testEnvironment.GetMainImage();
+            EmittedAssemblyPdb = testEnvironment.GetMainPdb();
+            _testData = ((IInternalRuntimeEnvironment)testEnvironment).GetCompilationTestData();
 
-            private CompilationVerifier VerifyILImpl(
-                string qualifiedMethodName,
-                string expectedIL,
-                bool realIL,
-                string sequencePoints,
-                string callerPath,
-                int callerLine,
-                bool escapeQuotes,
-                string source = null)
-            {
-                string actualIL = VisualizeIL(qualifiedMethodName, realIL, sequencePoints, source);
-                AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes, callerPath, callerLine);
-                return this;
-            }
+            return _compilation.Assembly.Identity.GetDisplayName();
+        }
 
-            public CompilationVerifier VerifyPdb(
-                XElement expectedPdb,
-                IMethodSymbol debugEntryPoint = null,
-                DebugInformationFormat format = 0,
-                PdbToXmlOptions options = 0,
-                [CallerLineNumber]int expectedValueSourceLine = 0,
-                [CallerFilePath]string expectedValueSourcePath = null)
-            {
-                _compilation.VerifyPdb(expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
-                return this;
-            }
+        public CompilationVerifier VerifyIL(
+            string qualifiedMethodName,
+            XCData expectedIL,
+            bool realIL = false,
+            string sequencePoints = null,
+            [CallerFilePath]string callerPath = null,
+            [CallerLineNumber]int callerLine = 0)
+        {
+            return VerifyILImpl(qualifiedMethodName, expectedIL.Value, realIL, sequencePoints, callerPath, callerLine, escapeQuotes: false);
+        }
 
-            public CompilationVerifier VerifyPdb(
-                string expectedPdb,
-                IMethodSymbol debugEntryPoint = null,
-                DebugInformationFormat format = 0,
-                PdbToXmlOptions options = 0,
-                [CallerLineNumber]int expectedValueSourceLine = 0,
-                [CallerFilePath]string expectedValueSourcePath = null)
-            {
-                _compilation.VerifyPdb(expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
-                return this;
-            }
+        public CompilationVerifier VerifyIL(
+            string qualifiedMethodName,
+            string expectedIL,
+            bool realIL = false,
+            string sequencePoints = null,
+            [CallerFilePath]string callerPath = null,
+            [CallerLineNumber]int callerLine = 0,
+            string source = null)
+        {
+            return VerifyILImpl(qualifiedMethodName, expectedIL, realIL, sequencePoints, callerPath, callerLine, escapeQuotes: true, source: source);
+        }
 
-            public CompilationVerifier VerifyPdb(
-                string qualifiedMethodName,
-                string expectedPdb,
-                IMethodSymbol debugEntryPoint = null,
-                DebugInformationFormat format = 0,
-                PdbToXmlOptions options = 0,
-                [CallerLineNumber]int expectedValueSourceLine = 0,
-                [CallerFilePath]string expectedValueSourcePath = null)
-            {
-                _compilation.VerifyPdb(qualifiedMethodName, expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
-                return this;
-            }
+        public void VerifyLocalSignature(
+            string qualifiedMethodName,
+            string expectedSignature,
+            [CallerLineNumber]int callerLine = 0,
+            [CallerFilePath]string callerPath = null)
+        {
+            var ilBuilder = _testData.GetMethodData(qualifiedMethodName).ILBuilder;
+            string actualSignature = ILBuilderVisualizer.LocalSignatureToString(ilBuilder);
+            AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, actualSignature, escapeQuotes: true, expectedValueSourcePath: callerPath, expectedValueSourceLine: callerLine);
+        }
 
-            public CompilationVerifier VerifyPdb(
-                string qualifiedMethodName,
-                XElement expectedPdb,
-                IMethodSymbol debugEntryPoint = null,
-                DebugInformationFormat format = 0,
-                PdbToXmlOptions options = 0,
-                [CallerLineNumber]int expectedValueSourceLine = 0,
-                [CallerFilePath]string expectedValueSourcePath = null)
-            {
-                _compilation.VerifyPdb(qualifiedMethodName, expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
-                return this;
-            }
+        private CompilationVerifier VerifyILImpl(
+            string qualifiedMethodName,
+            string expectedIL,
+            bool realIL,
+            string sequencePoints,
+            string callerPath,
+            int callerLine,
+            bool escapeQuotes,
+            string source = null)
+        {
+            string actualIL = VisualizeIL(qualifiedMethodName, realIL, sequencePoints, source);
+            AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes, callerPath, callerLine);
+            return this;
+        }
 
-            public ISymUnmanagedReader3 CreateSymReader()
-            {
-                var pdbStream = new MemoryStream(EmittedAssemblyPdb.ToArray());
-                return SymReaderFactory.CreateReader(pdbStream, metadataReaderOpt: null, metadataMemoryOwnerOpt: null);
-            }
+        public CompilationVerifier VerifyPdb(
+            XElement expectedPdb,
+            IMethodSymbol debugEntryPoint = null,
+            DebugInformationFormat format = 0,
+            PdbToXmlOptions options = 0,
+            [CallerLineNumber]int expectedValueSourceLine = 0,
+            [CallerFilePath]string expectedValueSourcePath = null)
+        {
+            _compilation.VerifyPdb(expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
+            return this;
+        }
 
-            public string VisualizeIL(string qualifiedMethodName, bool realIL = false, string sequencePoints = null, string source = null)
-            {
-                // TODO: Currently the qualifiedMethodName is a symbol display name while PDB need metadata name.
-                // So we need to pass the PDB metadata name of the method to sequencePoints (instead of just bool).
+        public CompilationVerifier VerifyPdb(
+            string expectedPdb,
+            IMethodSymbol debugEntryPoint = null,
+            DebugInformationFormat format = 0,
+            PdbToXmlOptions options = 0,
+            [CallerLineNumber]int expectedValueSourceLine = 0,
+            [CallerFilePath]string expectedValueSourcePath = null)
+        {
+            _compilation.VerifyPdb(expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
+            return this;
+        }
 
-                return VisualizeIL(_testData.GetMethodData(qualifiedMethodName), realIL, sequencePoints, source);
-            }
+        public CompilationVerifier VerifyPdb(
+            string qualifiedMethodName,
+            string expectedPdb,
+            IMethodSymbol debugEntryPoint = null,
+            DebugInformationFormat format = 0,
+            PdbToXmlOptions options = 0,
+            [CallerLineNumber]int expectedValueSourceLine = 0,
+            [CallerFilePath]string expectedValueSourcePath = null)
+        {
+            _compilation.VerifyPdb(qualifiedMethodName, expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
+            return this;
+        }
 
-            internal string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints = null, string source = null)
-            {
-                Dictionary<int, string> markers = null;
+        public CompilationVerifier VerifyPdb(
+            string qualifiedMethodName,
+            XElement expectedPdb,
+            IMethodSymbol debugEntryPoint = null,
+            DebugInformationFormat format = 0,
+            PdbToXmlOptions options = 0,
+            [CallerLineNumber]int expectedValueSourceLine = 0,
+            [CallerFilePath]string expectedValueSourcePath = null)
+        {
+            _compilation.VerifyPdb(qualifiedMethodName, expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
+            return this;
+        }
 
-                if (sequencePoints != null)
-                {
-                    var actualPdbXml = PdbToXmlConverter.ToXml(
-                        pdbStream: new MemoryStream(EmittedAssemblyPdb.ToArray()),
-                        peStream: new MemoryStream(EmittedAssemblyData.ToArray()),
-                        options: PdbToXmlOptions.ResolveTokens |
-                                 PdbToXmlOptions.ThrowOnError |
-                                 PdbToXmlOptions.ExcludeDocuments |
-                                 PdbToXmlOptions.ExcludeCustomDebugInformation |
-                                 PdbToXmlOptions.ExcludeScopes,
-                        methodName: sequencePoints);
-
-                    markers = PdbValidation.GetMarkers(actualPdbXml, source);
-                }
+        public ISymUnmanagedReader3 CreateSymReader()
+        {
+            var pdbStream = new MemoryStream(EmittedAssemblyPdb.ToArray());
+            return SymReaderFactory.CreateReader(pdbStream, metadataReaderOpt: null, metadataMemoryOwnerOpt: null);
+        }
 
-                if (!realIL)
-                {
-                    return ILBuilderVisualizer.ILBuilderToString(methodData.ILBuilder, markers: markers);
-                }
+        public string VisualizeIL(string qualifiedMethodName, bool realIL = false, string sequencePoints = null, string source = null)
+        {
+            // TODO: Currently the qualifiedMethodName is a symbol display name while PDB need metadata name.
+            // So we need to pass the PDB metadata name of the method to sequencePoints (instead of just bool).
 
-                if (_lazyModuleSymbol == null)
-                {
-                    _lazyModuleSymbol = GetModuleSymbolForEmittedImage(EmittedAssemblyData, MetadataImportOptions.All);
-                }
+            return VisualizeIL(_testData.GetMethodData(qualifiedMethodName), realIL, sequencePoints, source);
+        }
 
-                return _lazyModuleSymbol != null ? _visualizeRealIL(_lazyModuleSymbol, methodData, markers) : null;
-            }
+        internal string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints = null, string source = null)
+        {
+            Dictionary<int, string> markers = null;
 
-            public CompilationVerifier VerifyMemberInIL(string methodName, bool expected)
+            if (sequencePoints != null)
             {
-                Assert.Equal(expected, _testData.GetMethodsByName().ContainsKey(methodName));
-                return this;
+                var actualPdbXml = PdbToXmlConverter.ToXml(
+                    pdbStream: new MemoryStream(EmittedAssemblyPdb.ToArray()),
+                    peStream: new MemoryStream(EmittedAssemblyData.ToArray()),
+                    options: PdbToXmlOptions.ResolveTokens |
+                             PdbToXmlOptions.ThrowOnError |
+                             PdbToXmlOptions.ExcludeDocuments |
+                             PdbToXmlOptions.ExcludeCustomDebugInformation |
+                             PdbToXmlOptions.ExcludeScopes,
+                    methodName: sequencePoints);
+
+                markers = PdbValidation.GetMarkers(actualPdbXml, source);
             }
 
-            public CompilationVerifier VerifyDiagnostics(params DiagnosticDescription[] expected)
+            if (!realIL)
             {
-                _diagnostics.Verify(expected);
-                return this;
+                return ILBuilderVisualizer.ILBuilderToString(methodData.ILBuilder, markers: markers);
             }
 
-            public IModuleSymbol GetModuleSymbolForEmittedImage()
+            if (_lazyModuleSymbol == null)
             {
-                return GetModuleSymbolForEmittedImage(EmittedAssemblyData, _compilation.Options.MetadataImportOptions);
+                _lazyModuleSymbol = GetModuleSymbolForEmittedImage(EmittedAssemblyData, MetadataImportOptions.All);
             }
 
-            private IModuleSymbol GetModuleSymbolForEmittedImage(ImmutableArray<byte> peImage, MetadataImportOptions importOptions)
-            {
-                if (peImage.IsDefault)
-                {
-                    return null;
-                }
+            return _lazyModuleSymbol != null ? _visualizeRealIL(_lazyModuleSymbol, methodData, markers) : null;
+        }
 
-                var targetReference = LoadTestEmittedExecutableForSymbolValidation(peImage, _compilation.Options.OutputKind, display: _compilation.AssemblyName);
-                var references = _compilation.References.Concat(new[] { targetReference });
-                var assemblies = GetReferencesToModuleSymbols(references, importOptions);
-                return assemblies.Last();
-            }
+        public CompilationVerifier VerifyMemberInIL(string methodName, bool expected)
+        {
+            Assert.Equal(expected, _testData.GetMethodsByName().ContainsKey(methodName));
+            return this;
+        }
+
+        public CompilationVerifier VerifyDiagnostics(params DiagnosticDescription[] expected)
+        {
+            _diagnostics.Verify(expected);
+            return this;
+        }
+
+        public IModuleSymbol GetModuleSymbolForEmittedImage()
+        {
+            return GetModuleSymbolForEmittedImage(EmittedAssemblyData, _compilation.Options.MetadataImportOptions);
+        }
 
-            private IEnumerable<IModuleSymbol> GetReferencesToModuleSymbols(IEnumerable<MetadataReference> references, MetadataImportOptions importOptions)
+        private IModuleSymbol GetModuleSymbolForEmittedImage(ImmutableArray<byte> peImage, MetadataImportOptions importOptions)
+        {
+            if (peImage.IsDefault)
             {
-                var dummy = _compilation
-                    .RemoveAllReferences()
-                    .RemoveAllSyntaxTrees()
-                    .WithReferences(references)
-                    .WithAssemblyName("Dummy")
-                    .WithOptions(_compilation.Options.WithMetadataImportOptions(importOptions));
-
-                return references.Select(reference =>
-                {
-                    if (reference.Properties.Kind == MetadataImageKind.Assembly)
-                    {
-                        return ((IAssemblySymbol)dummy.GetAssemblyOrModuleSymbol(reference))?.Modules.First();
-                    }
-                    else
-                    {
-                        return (IModuleSymbol)dummy.GetAssemblyOrModuleSymbol(reference);
-                    }
-                });
+                return null;
             }
+            var targetReference = LoadTestEmittedExecutableForSymbolValidation(peImage, _compilation.Options.OutputKind, display: _compilation.AssemblyName);
+            var references = _compilation.References.Concat(new[] { targetReference });
+            var assemblies = GetReferencesToModuleSymbols(references, importOptions);
+            return assemblies.Last();
+        }
 
-            internal static MetadataReference LoadTestEmittedExecutableForSymbolValidation(
-                ImmutableArray<byte> image,
-                OutputKind outputKind,
-                string display = null)
-            {
-                var moduleMetadata = ModuleMetadata.CreateFromImage(image);
-                moduleMetadata.Module.PretendThereArentNoPiaLocalTypes();
+        private IEnumerable<IModuleSymbol> GetReferencesToModuleSymbols(IEnumerable<MetadataReference> references, MetadataImportOptions importOptions)
+        {
+            var dummy = _compilation
+                .RemoveAllSyntaxTrees()
+                .WithReferences(references)
+                .WithAssemblyName("Dummy")
+                .WithOptions(_compilation.Options.WithMetadataImportOptions(importOptions));
 
-                if (outputKind == OutputKind.NetModule)
+            return references.Select(reference =>
+            {
+                if (reference.Properties.Kind == MetadataImageKind.Assembly)
                 {
-                    return moduleMetadata.GetReference(display: display);
+                    return ((IAssemblySymbol)dummy.GetAssemblyOrModuleSymbol(reference))?.Modules.First();
                 }
                 else
                 {
-                    return AssemblyMetadata.Create(moduleMetadata).GetReference(display: display);
+                    return (IModuleSymbol)dummy.GetAssemblyOrModuleSymbol(reference);
                 }
-            }
+            });
+        }
+
+        internal static MetadataReference LoadTestEmittedExecutableForSymbolValidation(
+            ImmutableArray<byte> image,
+            OutputKind outputKind,
+            string display = null)
+        {
+            var moduleMetadata = ModuleMetadata.CreateFromImage(image);
+            moduleMetadata.Module.PretendThereArentNoPiaLocalTypes();
 
-            public void VerifyOperationTree(string expectedOperationTree, bool skipImplicitlyDeclaredSymbols = false)
+            if (outputKind == OutputKind.NetModule)
             {
-                _compilation.VerifyOperationTree(expectedOperationTree, skipImplicitlyDeclaredSymbols);
+                return moduleMetadata.GetReference(display: display);
             }
-
-            public void VerifyOperationTree(string symbolToVerify, string expectedOperationTree, bool skipImplicitlyDeclaredSymbols = false)
+            else
             {
-                _compilation.VerifyOperationTree(symbolToVerify, expectedOperationTree, skipImplicitlyDeclaredSymbols);
+                return AssemblyMetadata.Create(moduleMetadata).GetReference(display: display);
             }
         }
+
+        public void VerifyOperationTree(string expectedOperationTree, bool skipImplicitlyDeclaredSymbols = false)
+        {
+            _compilation.VerifyOperationTree(expectedOperationTree, skipImplicitlyDeclaredSymbols);
+        }
+
+        public void VerifyOperationTree(string symbolToVerify, string expectedOperationTree, bool skipImplicitlyDeclaredSymbols = false)
+        {
+            _compilation.VerifyOperationTree(symbolToVerify, expectedOperationTree, skipImplicitlyDeclaredSymbols);
+        }
     }
 }

From f68ed5a162e9caaed9524d36261026b3380006b7 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Thu, 11 May 2017 16:17:24 -0700
Subject: [PATCH 231/284] Rename file

---
 ...onTestBase.CompilationVerifier.cs => CompilationVerifier.cs} | 0
 src/Test/Utilities/Portable/TestUtilities.csproj                | 2 +-
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/Test/Utilities/Portable/{CommonTestBase.CompilationVerifier.cs => CompilationVerifier.cs} (100%)

diff --git a/src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs b/src/Test/Utilities/Portable/CompilationVerifier.cs
similarity index 100%
rename from src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs
rename to src/Test/Utilities/Portable/CompilationVerifier.cs
diff --git a/src/Test/Utilities/Portable/TestUtilities.csproj b/src/Test/Utilities/Portable/TestUtilities.csproj
index d434232356b00..c5818055de02f 100644
--- a/src/Test/Utilities/Portable/TestUtilities.csproj
+++ b/src/Test/Utilities/Portable/TestUtilities.csproj
@@ -99,7 +99,7 @@
     <Compile Include="Assert\EqualityUtil`1.cs" />
     <Compile Include="Assert\TestExceptionUtilities.cs" />
     <Compile Include="Assert\WorkItemAttribute.cs" />
-    <Compile Include="CommonTestBase.CompilationVerifier.cs" />
+    <Compile Include="CompilationVerifier.cs" />
     <Compile Include="CommonTestBase.cs" />
     <Compile Include="Compilation\CompilationDifference.cs" />
     <Compile Include="Compilation\CompilationExtensions.cs" />

From a4491d2b8527afab39a4245a834e9ff971701800 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Thu, 11 May 2017 17:52:10 -0700
Subject: [PATCH 232/284] Remove dependency on PDB reader from TestBase

---
 .../CSharp/Test/Emit/PDB/PDBUsingTests.cs     |   2 +-
 .../Test/Emit/PDB/PDBNamespaceScopes.vb       |   3 +-
 .../Test/Emit/PDB/PDBSyncLockTests.vb         |   1 +
 .../Compilation/CompilationDifference.cs      |  64 +----
 .../Utilities/Portable/CompilationVerifier.cs |  60 +---
 .../Portable/Metadata/MetadataValidation.cs   |  38 +++
 .../MetadataSignatureUnitTestHelper.cs        | 170 -----------
 .../Portable/Pdb/PdbTestUtilities.cs          |   8 +
 .../Utilities/Portable/Pdb/PdbValidation.cs   | 267 +++++++-----------
 .../Utilities/Portable/TestUtilities.csproj   |   3 +-
 10 files changed, 164 insertions(+), 452 deletions(-)
 delete mode 100644 src/Test/Utilities/Portable/MetadataSignatureUnitTestHelper.cs

diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBUsingTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBUsingTests.cs
index da40616e9f663..1b563f9ad1b54 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBUsingTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBUsingTests.cs
@@ -2214,7 +2214,7 @@ class C
             var emitResult1 = c.Emit(peStream: peStream1, pdbStream: pdbStream);
             var emitResult2 = c.Emit(peStream: peStream2);
 
-            PdbValidation.VerifyMetadataEqualModuloMvid(peStream1, peStream2);
+            MetadataValidation.VerifyMetadataEqualModuloMvid(peStream1, peStream2);
         }
 
         [Fact]
diff --git a/src/Compilers/VisualBasic/Test/Emit/PDB/PDBNamespaceScopes.vb b/src/Compilers/VisualBasic/Test/Emit/PDB/PDBNamespaceScopes.vb
index e668b3c36529d..ea2f5e213e2ff 100644
--- a/src/Compilers/VisualBasic/Test/Emit/PDB/PDBNamespaceScopes.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/PDB/PDBNamespaceScopes.vb
@@ -2,6 +2,7 @@
 
 Imports System.IO
 Imports Microsoft.CodeAnalysis.Test.Utilities
+Imports Roslyn.Test.Utilities
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.PDB
     Public Class PDBNamespaceScopes
@@ -383,7 +384,7 @@ End Class
             Dim emitResult1 = c.Emit(peStream:=peStream1, pdbStream:=pdbStream)
             Dim emitResult2 = c.Emit(peStream:=peStream2)
 
-            PdbValidation.VerifyMetadataEqualModuloMvid(peStream1, peStream2)
+            MetadataValidation.VerifyMetadataEqualModuloMvid(peStream1, peStream2)
         End Sub
 
         <Fact>
diff --git a/src/Compilers/VisualBasic/Test/Emit/PDB/PDBSyncLockTests.vb b/src/Compilers/VisualBasic/Test/Emit/PDB/PDBSyncLockTests.vb
index 8247d7bba772a..f4931e5c11505 100644
--- a/src/Compilers/VisualBasic/Test/Emit/PDB/PDBSyncLockTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/PDB/PDBSyncLockTests.vb
@@ -1,4 +1,5 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+Imports Microsoft.CodeAnalysis.Test.Utilities
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.PDB
 
diff --git a/src/Test/Utilities/Portable/Compilation/CompilationDifference.cs b/src/Test/Utilities/Portable/Compilation/CompilationDifference.cs
index 40bfaa8f37286..ac45563dd2bc8 100644
--- a/src/Test/Utilities/Portable/Compilation/CompilationDifference.cs
+++ b/src/Test/Utilities/Portable/Compilation/CompilationDifference.cs
@@ -3,35 +3,30 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.IO;
 using System.Linq;
 using System.Reflection.Metadata;
 using System.Reflection.Metadata.Ecma335;
 using System.Runtime.CompilerServices;
-using System.Xml.Linq;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.Emit;
-using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.DiaSymReader.Tools;
 using Microsoft.Metadata.Tools;
 using Roslyn.Test.MetadataUtilities;
-using Roslyn.Test.PdbUtilities;
 using Roslyn.Test.Utilities;
-using Xunit;
 
 namespace Microsoft.CodeAnalysis.Test.Utilities
 {
-    internal sealed class CompilationDifference
+    public sealed class CompilationDifference
     {
         public readonly ImmutableArray<byte> MetadataDelta;
         public readonly ImmutableArray<byte> ILDelta;
         public readonly ImmutableArray<byte> PdbDelta;
-        public readonly CompilationTestData TestData;
+        internal readonly CompilationTestData TestData;
         public readonly EmitDifferenceResult EmitResult;
         public readonly ImmutableArray<MethodDefinitionHandle> UpdatedMethods;
 
-        public CompilationDifference(
+        internal CompilationDifference(
             ImmutableArray<byte> metadata,
             ImmutableArray<byte> il,
             ImmutableArray<byte> pdb,
@@ -55,7 +50,7 @@ public EmitBaseline NextGeneration
             }
         }
 
-        public PinnedMetadata GetMetadata()
+        internal PinnedMetadata GetMetadata()
         {
             return new PinnedMetadata(MetadataDelta);
         }
@@ -80,7 +75,7 @@ public void VerifyLocalSignature(
             AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, actualSignature, escapeQuotes: true, expectedValueSourcePath: callerPath, expectedValueSourceLine: callerLine);
         }
 
-        public void VerifyIL(
+        internal void VerifyIL(
             string qualifiedMethodName,
             string expectedIL,
             Func<Cci.ILocalDefinition, ILVisualizer.LocalInfo> mapLocal = null,
@@ -94,60 +89,13 @@ public void VerifyIL(
             if (!methodToken.IsNil)
             {
                 string actualPdb = PdbToXmlConverter.DeltaPdbToXml(new ImmutableMemoryStream(PdbDelta), new[] { MetadataTokens.GetToken(methodToken) });
-                sequencePointMarkers = PdbValidation.GetMarkers(actualPdb);
+                sequencePointMarkers = ILValidation.GetSequencePointMarkers(actualPdb);
             }
 
             string actualIL = ILBuilderVisualizer.ILBuilderToString(ilBuilder, mapLocal ?? ToLocalInfo, sequencePointMarkers);
             AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes: true, expectedValueSourcePath: callerPath, expectedValueSourceLine: callerLine);
         }
 
-        public void VerifyPdb(IEnumerable<MethodDefinitionHandle> methodHandles, string expectedPdb)
-        {
-            VerifyPdb(methodHandles.Select(h => MetadataTokens.GetToken(h)), expectedPdb);
-        }
-
-        public void VerifyPdb(IEnumerable<MethodDefinitionHandle> methodHandles, XElement expectedPdb)
-        {
-            VerifyPdb(methodHandles.Select(h => MetadataTokens.GetToken(h)), expectedPdb);
-        }
-
-        public void VerifyPdb(
-            IEnumerable<int> methodTokens,
-            string expectedPdb,
-            DebugInformationFormat format = DebugInformationFormat.Pdb,
-            [CallerLineNumber]int expectedValueSourceLine = 0,
-            [CallerFilePath]string expectedValueSourcePath = null)
-        {
-            VerifyPdb(methodTokens, expectedPdb, format, expectedValueSourceLine, expectedValueSourcePath, expectedIsXmlLiteral: false);
-        }
-
-        public void VerifyPdb(
-            IEnumerable<int> methodTokens,
-            XElement expectedPdb,
-            DebugInformationFormat format = DebugInformationFormat.Pdb,
-            [CallerLineNumber]int expectedValueSourceLine = 0,
-            [CallerFilePath]string expectedValueSourcePath = null)
-        {
-            VerifyPdb(methodTokens, expectedPdb.ToString(), format, expectedValueSourceLine, expectedValueSourcePath, expectedIsXmlLiteral: true);
-        }
-
-        private void VerifyPdb(
-            IEnumerable<int> methodTokens,
-            string expectedPdb,
-            DebugInformationFormat format,
-            int expectedValueSourceLine,
-            string expectedValueSourcePath,
-            bool expectedIsXmlLiteral)
-        {
-            Assert.NotEqual(default(DebugInformationFormat), format);
-            Assert.NotEqual(DebugInformationFormat.Embedded, format);
-
-            string actualPdb = PdbToXmlConverter.DeltaPdbToXml(new ImmutableMemoryStream(PdbDelta), methodTokens);
-            var (actualXml, expectedXml) = PdbValidation.AdjustToPdbFormat(actualPdb, expectedPdb, actualIsPortable: NextGeneration.InitialBaseline.HasPortablePdb);
-
-            AssertXml.Equal(expectedXml, actualXml, $"Format: {format}{Environment.NewLine}", expectedValueSourcePath, expectedValueSourceLine, expectedIsXmlLiteral);
-        }
-
         internal string GetMethodIL(string qualifiedMethodName)
         {
             return ILBuilderVisualizer.ILBuilderToString(this.TestData.GetMethodData(qualifiedMethodName).ILBuilder, ToLocalInfo);
diff --git a/src/Test/Utilities/Portable/CompilationVerifier.cs b/src/Test/Utilities/Portable/CompilationVerifier.cs
index b38100c8d7c75..a43bce9f07e29 100644
--- a/src/Test/Utilities/Portable/CompilationVerifier.cs
+++ b/src/Test/Utilities/Portable/CompilationVerifier.cs
@@ -10,9 +10,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.Emit;
-using Microsoft.DiaSymReader;
 using Microsoft.DiaSymReader.Tools;
-using Roslyn.Test.PdbUtilities;
 using Roslyn.Test.Utilities;
 using Xunit;
 
@@ -170,62 +168,6 @@ private CompilationVerifier VerifyILImpl(
             return this;
         }
 
-        public CompilationVerifier VerifyPdb(
-            XElement expectedPdb,
-            IMethodSymbol debugEntryPoint = null,
-            DebugInformationFormat format = 0,
-            PdbToXmlOptions options = 0,
-            [CallerLineNumber]int expectedValueSourceLine = 0,
-            [CallerFilePath]string expectedValueSourcePath = null)
-        {
-            _compilation.VerifyPdb(expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
-            return this;
-        }
-
-        public CompilationVerifier VerifyPdb(
-            string expectedPdb,
-            IMethodSymbol debugEntryPoint = null,
-            DebugInformationFormat format = 0,
-            PdbToXmlOptions options = 0,
-            [CallerLineNumber]int expectedValueSourceLine = 0,
-            [CallerFilePath]string expectedValueSourcePath = null)
-        {
-            _compilation.VerifyPdb(expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
-            return this;
-        }
-
-        public CompilationVerifier VerifyPdb(
-            string qualifiedMethodName,
-            string expectedPdb,
-            IMethodSymbol debugEntryPoint = null,
-            DebugInformationFormat format = 0,
-            PdbToXmlOptions options = 0,
-            [CallerLineNumber]int expectedValueSourceLine = 0,
-            [CallerFilePath]string expectedValueSourcePath = null)
-        {
-            _compilation.VerifyPdb(qualifiedMethodName, expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
-            return this;
-        }
-
-        public CompilationVerifier VerifyPdb(
-            string qualifiedMethodName,
-            XElement expectedPdb,
-            IMethodSymbol debugEntryPoint = null,
-            DebugInformationFormat format = 0,
-            PdbToXmlOptions options = 0,
-            [CallerLineNumber]int expectedValueSourceLine = 0,
-            [CallerFilePath]string expectedValueSourcePath = null)
-        {
-            _compilation.VerifyPdb(qualifiedMethodName, expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
-            return this;
-        }
-
-        public ISymUnmanagedReader3 CreateSymReader()
-        {
-            var pdbStream = new MemoryStream(EmittedAssemblyPdb.ToArray());
-            return SymReaderFactory.CreateReader(pdbStream, metadataReaderOpt: null, metadataMemoryOwnerOpt: null);
-        }
-
         public string VisualizeIL(string qualifiedMethodName, bool realIL = false, string sequencePoints = null, string source = null)
         {
             // TODO: Currently the qualifiedMethodName is a symbol display name while PDB need metadata name.
@@ -250,7 +192,7 @@ internal string VisualizeIL(CompilationTestData.MethodData methodData, bool real
                              PdbToXmlOptions.ExcludeScopes,
                     methodName: sequencePoints);
 
-                markers = PdbValidation.GetMarkers(actualPdbXml, source);
+                markers = ILValidation.GetSequencePointMarkers(actualPdbXml, source);
             }
 
             if (!realIL)
diff --git a/src/Test/Utilities/Portable/Metadata/MetadataValidation.cs b/src/Test/Utilities/Portable/Metadata/MetadataValidation.cs
index 67203dcb1554c..a0d02346162fb 100644
--- a/src/Test/Utilities/Portable/Metadata/MetadataValidation.cs
+++ b/src/Test/Utilities/Portable/Metadata/MetadataValidation.cs
@@ -2,10 +2,15 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using System.Reflection;
 using System.Reflection.Metadata;
 using System.Reflection.Metadata.Ecma335;
+using System.Reflection.PortableExecutable;
 using Microsoft.CodeAnalysis;
+using Microsoft.Metadata.Tools;
+using Roslyn.Utilities;
 using Xunit;
 
 namespace Roslyn.Test.Utilities
@@ -144,5 +149,38 @@ internal static IEnumerable<string> GetExportedTypesFullNames(MetadataReader met
                 yield return (ns.Length == 0) ? name : (ns + "." + name);
             }
         }
+
+        public static void VerifyMetadataEqualModuloMvid(Stream peStream1, Stream peStream2)
+        {
+            peStream1.Position = 0;
+            peStream2.Position = 0;
+
+            var peReader1 = new PEReader(peStream1);
+            var peReader2 = new PEReader(peStream2);
+
+            var md1 = peReader1.GetMetadata().GetContent();
+            var md2 = peReader2.GetMetadata().GetContent();
+
+            var mdReader1 = peReader1.GetMetadataReader();
+            var mdReader2 = peReader2.GetMetadataReader();
+
+            var mvidIndex1 = mdReader1.GetModuleDefinition().Mvid;
+            var mvidIndex2 = mdReader2.GetModuleDefinition().Mvid;
+
+            var mvidOffset1 = mdReader1.GetHeapMetadataOffset(HeapIndex.Guid) + 16 * (MetadataTokens.GetHeapOffset(mvidIndex1) - 1);
+            var mvidOffset2 = mdReader2.GetHeapMetadataOffset(HeapIndex.Guid) + 16 * (MetadataTokens.GetHeapOffset(mvidIndex2) - 1);
+
+            if (!md1.RemoveRange(mvidOffset1, 16).SequenceEqual(md1.RemoveRange(mvidOffset2, 16)))
+            {
+                var mdw1 = new StringWriter();
+                var mdw2 = new StringWriter();
+                new MetadataVisualizer(mdReader1, mdw1).Visualize();
+                new MetadataVisualizer(mdReader2, mdw2).Visualize();
+                mdw1.Flush();
+                mdw2.Flush();
+
+                AssertEx.AssertResultsEqual(mdw1.ToString(), mdw2.ToString());
+            }
+        }
     }
 }
diff --git a/src/Test/Utilities/Portable/MetadataSignatureUnitTestHelper.cs b/src/Test/Utilities/Portable/MetadataSignatureUnitTestHelper.cs
deleted file mode 100644
index dd2308fc6fa89..0000000000000
--- a/src/Test/Utilities/Portable/MetadataSignatureUnitTestHelper.cs
+++ /dev/null
@@ -1,170 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Generic;
-using System.Linq;
-using Microsoft.CodeAnalysis.Text;
-using Roslyn.Test.Utilities;
-using Xunit;
-
-namespace Microsoft.CodeAnalysis.Test.Utilities
-{
-    internal class MetadataSignatureUnitTestHelper
-    {
-        /// <summary>
-        /// Uses Reflection to verify that the specified member signatures are present in emitted metadata
-        /// </summary>
-        /// <param name="appDomainHost">Unit test AppDomain host</param>
-        /// <param name="expectedSignatures">Baseline signatures - use the Signature() factory method to create instances of SignatureDescription</param>
-        internal static void VerifyMemberSignatures(
-            IRuntimeEnvironment appDomainHost, params SignatureDescription[] expectedSignatures)
-        {
-            Assert.NotNull(expectedSignatures);
-            Assert.NotEmpty(expectedSignatures);
-
-            var succeeded = true;
-            var expected = new List<string>();
-            var actual = new List<string>();
-
-            foreach (var signature in expectedSignatures)
-            {
-                List<string> actualSignatures = null;
-                var expectedSignature = signature.ExpectedSignature;
-
-                if (!VerifyMemberSignatureHelper(
-                    appDomainHost, signature.FullyQualifiedTypeName, signature.MemberName,
-                    ref expectedSignature, out actualSignatures))
-                {
-                    succeeded = false;
-                }
-
-                expected.Add(expectedSignature);
-                actual.AddRange(actualSignatures);
-            }
-
-            if (!succeeded)
-            {
-                TriggerSignatureMismatchFailure(expected, actual);
-            }
-        }
-
-        /// <summary>
-        /// Uses Reflection to verify that the specified member signature is present in emitted metadata
-        /// </summary>
-        /// <param name="appDomainHost">Unit test AppDomain host</param>
-        /// <param name="fullyQualifiedTypeName">
-        /// Fully qualified type name for member
-        /// Names must be in format recognized by reflection
-        /// e.g. MyType&lt;T&gt;.MyNestedType&lt;T, U&gt; => MyType`1+MyNestedType`2
-        /// </param>
-        /// <param name="memberName">
-        /// Name of member on specified type whose signature needs to be verified
-        /// Names must be in format recognized by reflection
-        /// e.g. For explicitly implemented member - I1&lt;string&gt;.Method => I1&lt;System.String&gt;.Method
-        /// </param>
-        /// <param name="expectedSignature">
-        /// Baseline string for signature of specified member
-        /// Skip this argument to get an error message that shows all available signatures for specified member
-        /// This argument is passed by reference and it will be updated with a formatted form of the baseline signature for error reporting purposes
-        /// </param>
-        /// <param name="actualSignatures">List of found signatures matching member name</param>
-        /// <returns>True if a matching member signature was found, false otherwise</returns>
-        private static bool VerifyMemberSignatureHelper(
-            IRuntimeEnvironment appDomainHost, string fullyQualifiedTypeName, string memberName,
-            ref string expectedSignature, out List<string> actualSignatures)
-        {
-            Assert.False(string.IsNullOrWhiteSpace(fullyQualifiedTypeName), "'fullyQualifiedTypeName' can't be null or empty");
-            Assert.False(string.IsNullOrWhiteSpace(memberName), "'memberName' can't be null or empty");
-
-            var retVal = true; actualSignatures = new List<string>();
-            var signatures = appDomainHost.GetMemberSignaturesFromMetadata(fullyQualifiedTypeName, memberName);
-            var signatureAssertText = "Signature(\"" + fullyQualifiedTypeName + "\", \"" + memberName + "\", \"{0}\"),";
-
-            if (!string.IsNullOrWhiteSpace(expectedSignature))
-            {
-                expectedSignature = expectedSignature.Replace("\"", "\\\"");
-            }
-            expectedSignature = string.Format(signatureAssertText, expectedSignature);
-
-            if (signatures.Count > 1)
-            {
-                var found = false;
-                foreach (var signature in signatures)
-                {
-                    var actualSignature = signature.Replace("\"", "\\\"");
-                    actualSignature = string.Format(signatureAssertText, actualSignature);
-
-                    if (actualSignature == expectedSignature)
-                    {
-                        actualSignatures.Clear();
-                        actualSignatures.Add(actualSignature);
-                        found = true; break;
-                    }
-                    else
-                    {
-                        actualSignatures.Add(actualSignature);
-                    }
-                }
-                if (!found)
-                {
-                    retVal = false;
-                }
-            }
-            else if (signatures.Count == 1)
-            {
-                var actualSignature = signatures.First().Replace("\"", "\\\"");
-                actualSignature = string.Format(signatureAssertText, actualSignature);
-                actualSignatures.Add(actualSignature);
-
-                if (expectedSignature != actualSignature)
-                {
-                    retVal = false;
-                }
-            }
-            else
-            {
-                retVal = false;
-            }
-
-            return retVal;
-        }
-
-        /// <summary>
-        /// Triggers assert when expected and actual signatures don't match
-        /// </summary>
-        /// <param name="expectedSignatures">List of baseline signature strings</param>
-        /// <param name="actualSignatures">List of actually found signature strings</param>
-        private static void TriggerSignatureMismatchFailure(List<string> expectedSignatures, List<string> actualSignatures)
-        {
-            var expectedText = string.Empty;
-            var actualText = string.Empty;
-            var distinctSignatures = new HashSet<string>();
-
-            foreach (var signature in expectedSignatures)
-            {
-                // We need to preserve the order as well as prevent duplicates
-                if (!distinctSignatures.Contains(signature))
-                {
-                    expectedText += "\n\t" + signature;
-                    distinctSignatures.Add(signature);
-                }
-            }
-
-            distinctSignatures.Clear();
-            foreach (var signature in actualSignatures)
-            {
-                // We need to preserve the order as well as prevent duplicates
-                if (!distinctSignatures.Contains(signature))
-                {
-                    actualText += "\n\t" + signature;
-                    distinctSignatures.Add(signature);
-                }
-            }
-
-            expectedText = expectedText.TrimEnd(',');
-            actualText = actualText.TrimEnd(',');
-            var diffText = DiffUtil.DiffReport(expectedText, actualText);
-
-            Assert.True(false, "\n\nExpected:" + expectedText + "\n\nActual:" + actualText + "\n\nDifferences:\n" + diffText);
-        }
-    }
-}
diff --git a/src/Test/Utilities/Portable/Pdb/PdbTestUtilities.cs b/src/Test/Utilities/Portable/Pdb/PdbTestUtilities.cs
index 67535a30ae2ff..d5958ebc34de4 100644
--- a/src/Test/Utilities/Portable/Pdb/PdbTestUtilities.cs
+++ b/src/Test/Utilities/Portable/Pdb/PdbTestUtilities.cs
@@ -6,8 +6,10 @@
 using System.Reflection.Metadata;
 using System.Runtime.InteropServices;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.Debugging;
 using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.DiaSymReader;
 using Roslyn.Test.PdbUtilities;
 
@@ -15,6 +17,12 @@ namespace Roslyn.Test.Utilities
 {
     internal static class PdbTestUtilities
     {
+        public static ISymUnmanagedReader3 CreateSymReader(this CompilationVerifier verifier)
+        {
+            var pdbStream = new ImmutableMemoryStream(verifier.EmittedAssemblyPdb);
+            return SymReaderFactory.CreateReader(pdbStream, metadataReaderOpt: null, metadataMemoryOwnerOpt: null);
+        }
+
         public unsafe static EditAndContinueMethodDebugInformation GetEncMethodDebugInfo(this ISymUnmanagedReader3 symReader, MethodDefinitionHandle handle)
         {
             const int S_OK = 0;
diff --git a/src/Test/Utilities/Portable/Pdb/PdbValidation.cs b/src/Test/Utilities/Portable/Pdb/PdbValidation.cs
index 5e424fd6a2142..70e78b94bd501 100644
--- a/src/Test/Utilities/Portable/Pdb/PdbValidation.cs
+++ b/src/Test/Utilities/Portable/Pdb/PdbValidation.cs
@@ -5,7 +5,6 @@
 using System.Collections.Immutable;
 using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Reflection.Metadata;
 using System.Reflection.Metadata.Ecma335;
 using System.Reflection.PortableExecutable;
@@ -14,12 +13,11 @@
 using System.Text;
 using System.Xml;
 using System.Xml.Linq;
-using Microsoft.CodeAnalysis.CodeGen;
+using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.Emit;
 using Microsoft.DiaSymReader;
 using Microsoft.DiaSymReader.Tools;
 using Microsoft.Metadata.Tools;
-using Roslyn.Test.MetadataUtilities;
 using Roslyn.Test.PdbUtilities;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
@@ -29,6 +27,110 @@ namespace Microsoft.CodeAnalysis.Test.Utilities
 {
     public static class PdbValidation
     {
+        public static CompilationVerifier VerifyPdb(
+            this CompilationVerifier verifier,
+            XElement expectedPdb,
+            IMethodSymbol debugEntryPoint = null,
+            DebugInformationFormat format = 0,
+            PdbToXmlOptions options = 0,
+            [CallerLineNumber]int expectedValueSourceLine = 0,
+            [CallerFilePath]string expectedValueSourcePath = null)
+        {
+            verifier.Compilation.VerifyPdb(expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
+            return verifier;
+        }
+
+        public static CompilationVerifier VerifyPdb(
+            this CompilationVerifier verifier,
+            string expectedPdb,
+            IMethodSymbol debugEntryPoint = null,
+            DebugInformationFormat format = 0,
+            PdbToXmlOptions options = 0,
+            [CallerLineNumber]int expectedValueSourceLine = 0,
+            [CallerFilePath]string expectedValueSourcePath = null)
+        {
+            verifier.Compilation.VerifyPdb(expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
+            return verifier;
+        }
+
+        public static CompilationVerifier VerifyPdb(
+            this CompilationVerifier verifier,
+            string qualifiedMethodName,
+            string expectedPdb,
+            IMethodSymbol debugEntryPoint = null,
+            DebugInformationFormat format = 0,
+            PdbToXmlOptions options = 0,
+            [CallerLineNumber]int expectedValueSourceLine = 0,
+            [CallerFilePath]string expectedValueSourcePath = null)
+        {
+            verifier.Compilation.VerifyPdb(qualifiedMethodName, expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
+            return verifier;
+        }
+
+        public static CompilationVerifier VerifyPdb(
+            this CompilationVerifier verifier,
+            string qualifiedMethodName,
+            XElement expectedPdb,
+            IMethodSymbol debugEntryPoint = null,
+            DebugInformationFormat format = 0,
+            PdbToXmlOptions options = 0,
+            [CallerLineNumber]int expectedValueSourceLine = 0,
+            [CallerFilePath]string expectedValueSourcePath = null)
+        {
+            verifier.Compilation.VerifyPdb(qualifiedMethodName, expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
+            return verifier;
+        }
+
+        public static void VerifyPdb(this CompilationDifference diff, IEnumerable<MethodDefinitionHandle> methodHandles, string expectedPdb)
+        {
+            VerifyPdb(diff, methodHandles.Select(h => MetadataTokens.GetToken(h)), expectedPdb);
+        }
+
+        public static void VerifyPdb(this CompilationDifference diff, IEnumerable<MethodDefinitionHandle> methodHandles, XElement expectedPdb)
+        {
+            VerifyPdb(diff, methodHandles.Select(h => MetadataTokens.GetToken(h)), expectedPdb);
+        }
+
+        public static void VerifyPdb(
+            this CompilationDifference diff,
+            IEnumerable<int> methodTokens,
+            string expectedPdb,
+            DebugInformationFormat format = DebugInformationFormat.Pdb,
+            [CallerLineNumber]int expectedValueSourceLine = 0,
+            [CallerFilePath]string expectedValueSourcePath = null)
+        {
+            VerifyPdb(diff, methodTokens, expectedPdb, format, expectedValueSourceLine, expectedValueSourcePath, expectedIsXmlLiteral: false);
+        }
+
+        public static void VerifyPdb(
+            this CompilationDifference diff,
+            IEnumerable<int> methodTokens,
+            XElement expectedPdb,
+            DebugInformationFormat format = DebugInformationFormat.Pdb,
+            [CallerLineNumber]int expectedValueSourceLine = 0,
+            [CallerFilePath]string expectedValueSourcePath = null)
+        {
+            VerifyPdb(diff, methodTokens, expectedPdb.ToString(), format, expectedValueSourceLine, expectedValueSourcePath, expectedIsXmlLiteral: true);
+        }
+
+        private static void VerifyPdb(
+            this CompilationDifference diff,
+            IEnumerable<int> methodTokens,
+            string expectedPdb,
+            DebugInformationFormat format,
+            int expectedValueSourceLine,
+            string expectedValueSourcePath,
+            bool expectedIsXmlLiteral)
+        {
+            Assert.NotEqual(default(DebugInformationFormat), format);
+            Assert.NotEqual(DebugInformationFormat.Embedded, format);
+
+            string actualPdb = PdbToXmlConverter.DeltaPdbToXml(new ImmutableMemoryStream(diff.PdbDelta), methodTokens);
+            var (actualXml, expectedXml) = AdjustToPdbFormat(actualPdb, expectedPdb, actualIsPortable: diff.NextGeneration.InitialBaseline.HasPortablePdb);
+
+            AssertXml.Equal(expectedXml, actualXml, $"Format: {format}{Environment.NewLine}", expectedValueSourcePath, expectedValueSourceLine, expectedIsXmlLiteral);
+        }
+
         internal static void VerifyPdb(
             this Compilation compilation,
             string expectedPdb,
@@ -406,164 +508,5 @@ private unsafe static void ValidatePortablePdbId(Stream pdbStream, byte[] stampI
                 Assert.Equal(id.ToArray(), expectedId);
             }
         }
-
-        public static void VerifyMetadataEqualModuloMvid(Stream peStream1, Stream peStream2)
-        {
-            peStream1.Position = 0;
-            peStream2.Position = 0;
-
-            var peReader1 = new PEReader(peStream1);
-            var peReader2 = new PEReader(peStream2);
-
-            var md1 = peReader1.GetMetadata().GetContent();
-            var md2 = peReader2.GetMetadata().GetContent();
-
-            var mdReader1 = peReader1.GetMetadataReader();
-            var mdReader2 = peReader2.GetMetadataReader();
-
-            var mvidIndex1 = mdReader1.GetModuleDefinition().Mvid;
-            var mvidIndex2 = mdReader2.GetModuleDefinition().Mvid;
-
-            var mvidOffset1 = mdReader1.GetHeapMetadataOffset(HeapIndex.Guid) + 16 * (MetadataTokens.GetHeapOffset(mvidIndex1) - 1);
-            var mvidOffset2 = mdReader2.GetHeapMetadataOffset(HeapIndex.Guid) + 16 * (MetadataTokens.GetHeapOffset(mvidIndex2) - 1);
-
-            if (!md1.RemoveRange(mvidOffset1, 16).SequenceEqual(md1.RemoveRange(mvidOffset2, 16)))
-            {
-                var mdw1 = new StringWriter();
-                var mdw2 = new StringWriter();
-                new MetadataVisualizer(mdReader1, mdw1).Visualize();
-                new MetadataVisualizer(mdReader2, mdw2).Visualize();
-                mdw1.Flush();
-                mdw2.Flush();
-
-                AssertEx.AssertResultsEqual(mdw1.ToString(), mdw2.ToString());
-            }
-        }
-
-        public static Dictionary<int, string> GetMarkers(string pdbXml, string source = null)
-        {
-            string[] lines = source?.Split(new[] { "\r\n" }, StringSplitOptions.None);
-            var doc = new XmlDocument();
-            doc.LoadXml(pdbXml);
-            var result = new Dictionary<int, string>();
-
-            if (source == null)
-            {
-                foreach (XmlNode entry in doc.GetElementsByTagName("sequencePoints"))
-                {
-                    foreach (XmlElement item in entry.ChildNodes)
-                    {
-                        Add(result,
-                            Convert.ToInt32(item.GetAttribute("offset"), 16),
-                            (item.GetAttribute("hidden") == "true") ? "~" : "-");
-                    }
-                }
-
-                foreach (XmlNode entry in doc.GetElementsByTagName("asyncInfo"))
-                {
-                    foreach (XmlElement item in entry.ChildNodes)
-                    {
-                        if (item.Name == "await")
-                        {
-                            Add(result, Convert.ToInt32(item.GetAttribute("yield"), 16), "<");
-                            Add(result, Convert.ToInt32(item.GetAttribute("resume"), 16), ">");
-                        }
-                        else if (item.Name == "catchHandler")
-                        {
-                            Add(result, Convert.ToInt32(item.GetAttribute("offset"), 16), "$");
-                        }
-                    }
-                }
-            }
-            else
-            {
-                foreach (XmlNode entry in doc.GetElementsByTagName("asyncInfo"))
-                {
-                    foreach (XmlElement item in entry.ChildNodes)
-                    {
-                        if (item.Name == "await")
-                        {
-                            AddTextual(result, Convert.ToInt32(item.GetAttribute("yield"), 16), "async: yield");
-                            AddTextual(result, Convert.ToInt32(item.GetAttribute("resume"), 16), "async: resume");
-                        }
-                        else if (item.Name == "catchHandler")
-                        {
-                            AddTextual(result, Convert.ToInt32(item.GetAttribute("offset"), 16), "async: catch handler");
-                        }
-                    }
-                }
-
-                foreach (XmlNode entry in doc.GetElementsByTagName("sequencePoints"))
-                {
-                    foreach (XmlElement item in entry.ChildNodes)
-                    {
-                        AddTextual(result, Convert.ToInt32(item.GetAttribute("offset"), 16), "sequence point: " + SnippetFromSpan(lines, item));
-                    }
-                }
-            }
-
-            return result;
-
-            void Add(Dictionary<int, string> dict, int key, string value)
-            {
-                if (dict.TryGetValue(key, out string found))
-                {
-                    dict[key] = found + value;
-                }
-                else
-                {
-                    dict[key] = value;
-                }
-            }
-
-            void AddTextual(Dictionary<int, string> dict, int key, string value)
-            {
-                if (dict.TryGetValue(key, out string found))
-                {
-                    dict[key] = found + ", " + value;
-                }
-                else
-                {
-                    dict[key] = "// " + value;
-                }
-            }
-        }
-
-        private static string SnippetFromSpan(string[] lines, XmlElement span)
-        {
-            if (span.GetAttribute("hidden") != "true")
-            {
-                var startLine = Convert.ToInt32(span.GetAttribute("startLine"));
-                var startColumn = Convert.ToInt32(span.GetAttribute("startColumn"));
-                var endLine = Convert.ToInt32(span.GetAttribute("endLine"));
-                var endColumn = Convert.ToInt32(span.GetAttribute("endColumn"));
-                if (startLine == endLine)
-                {
-                    return lines[startLine - 1].Substring(startColumn - 1, endColumn - startColumn);
-                }
-                else
-                {
-                    var start = lines[startLine - 1].Substring(startColumn - 1);
-                    var end = lines[endLine - 1].Substring(0, endColumn - 1);
-                    return TruncateStart(start, 12) + " ... " + TruncateEnd(end, 12);
-                }
-            }
-            else
-            {
-                return "<hidden>";
-            }
-
-            string TruncateStart(string text, int maxLength)
-            {
-                if (text.Length < maxLength) { return text; }
-                return text.Substring(0, maxLength);
-            }
-
-            string TruncateEnd(string text, int maxLength)
-            {
-                if (text.Length < maxLength) { return text; }
-                return text.Substring(text.Length - maxLength - 1, maxLength);
-            }
-        }
     }
 }
diff --git a/src/Test/Utilities/Portable/TestUtilities.csproj b/src/Test/Utilities/Portable/TestUtilities.csproj
index c5818055de02f..7d19457774576 100644
--- a/src/Test/Utilities/Portable/TestUtilities.csproj
+++ b/src/Test/Utilities/Portable/TestUtilities.csproj
@@ -151,12 +151,13 @@
     <Compile Include="ICompilationVerifier.cs" />
     <Compile Include="MarkedSource\MarkupTestFile.cs" />
     <Compile Include="MarkedSource\SourceWithMarkedNodes.cs" />
-    <Compile Include="MetadataSignatureUnitTestHelper.cs" />
+    <Compile Include="Metadata\MetadataSignatureUnitTestHelper.cs" />
     <Compile Include="Metadata\CustomAttributeRow.cs" />
     <Compile Include="Metadata\DynamicAnalysisDataReader.cs" />
     <Compile Include="Metadata\EncValidation.cs" />
     <Compile Include="Metadata\IlasmUtilities.cs" />
     <Compile Include="Metadata\ILBuilderVisualizer.cs" />
+    <Compile Include="Metadata\ILValidation.cs" />
     <Compile Include="Metadata\MetadataReaderUtils.cs" />
     <Compile Include="Metadata\MetadataValidation.cs" />
     <Compile Include="Metadata\ModuleData.cs" />

From 694edee0db45b0a4c4e6dab5d4e9edb52f3ad926 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Thu, 11 May 2017 19:04:41 -0700
Subject: [PATCH 233/284] PDB extensions cleanup

---
 .../Core/Portable/CodeAnalysis.csproj         |   1 +
 .../Test/EditorServicesTest.csproj            |   4 -
 .../ExpressionCompilerTestHelpers.cs          |   1 -
 .../Metadata/MethodILExtensions.cs            |  58 ------
 .../Pdb/MockSymWriter.cs                      |   0
 .../Pdb/PdbTestUtilities.cs                   |   2 +-
 .../Pdb/PdbValidation.cs                      |   8 +-
 src/Test/PdbUtilities/PdbUtilities.csproj     |  45 +++--
 .../CoreClr/TestUtilities.CoreClr.csproj      |   4 -
 .../Desktop/TestUtilities.Desktop.csproj      |   4 -
 .../Compilation/CompilationDifference.cs      |   1 -
 .../Utilities/Portable/CompilationVerifier.cs |   4 +-
 .../Metadata/AggregatedMetadataReader.cs      |   0
 .../Portable/Metadata/ILValidation.cs         | 186 ++++++++++++++++++
 .../MetadataSignatureUnitTestHelper.cs        | 170 ++++++++++++++++
 .../Utilities/Portable/TestUtilities.csproj   |  11 +-
 .../Test.Next/VisualStudioTest.Next.csproj    |   4 -
 17 files changed, 398 insertions(+), 105 deletions(-)
 delete mode 100644 src/Test/PdbUtilities/Metadata/MethodILExtensions.cs
 rename src/Test/{Utilities/Portable => PdbUtilities}/Pdb/MockSymWriter.cs (100%)
 rename src/Test/{Utilities/Portable => PdbUtilities}/Pdb/PdbTestUtilities.cs (98%)
 rename src/Test/{Utilities/Portable => PdbUtilities}/Pdb/PdbValidation.cs (99%)
 rename src/Test/{PdbUtilities => Utilities/Portable}/Metadata/AggregatedMetadataReader.cs (100%)
 create mode 100644 src/Test/Utilities/Portable/Metadata/ILValidation.cs
 create mode 100644 src/Test/Utilities/Portable/Metadata/MetadataSignatureUnitTestHelper.cs

diff --git a/src/Compilers/Core/Portable/CodeAnalysis.csproj b/src/Compilers/Core/Portable/CodeAnalysis.csproj
index 2079bd97be217..ab58e2793433d 100644
--- a/src/Compilers/Core/Portable/CodeAnalysis.csproj
+++ b/src/Compilers/Core/Portable/CodeAnalysis.csproj
@@ -899,6 +899,7 @@
     <InternalsVisibleToTest Include="Roslyn.Test.Utilities.Desktop" />
     <InternalsVisibleToTest Include="Roslyn.Test.Utilities.FX45" />
     <InternalsVisibleToTest Include="Roslyn.Test.Utilities" />
+    <InternalsVisibleToTest Include="Roslyn.Test.PdbUtilities" />
     <InternalsVisibleToTest Include="Roslyn.Compilers.CompilerServer.UnitTests" />
     <InternalsVisibleToMoq Include="DynamicProxyGenAssembly2" />
   </ItemGroup>
diff --git a/src/EditorFeatures/Test/EditorServicesTest.csproj b/src/EditorFeatures/Test/EditorServicesTest.csproj
index 5fd0df6032926..a8a83332d5a25 100644
--- a/src/EditorFeatures/Test/EditorServicesTest.csproj
+++ b/src/EditorFeatures/Test/EditorServicesTest.csproj
@@ -127,10 +127,6 @@
       <Project>{eba4dfa1-6ded-418f-a485-a3b608978906}</Project>
       <Name>InteractiveHost</Name>
     </ProjectReference>
-    <ProjectReference Include="..\..\Test\PdbUtilities\PdbUtilities.csproj">
-      <Project>{afde6bea-5038-4a4a-a88e-dbd2e4088eed}</Project>
-      <Name>PdbUtilities</Name>
-    </ProjectReference>
     <ProjectReference Include="..\..\Workspaces\Remote\Core\RemoteWorkspaces.csproj">
       <Project>{f822f72a-cc87-4e31-b57d-853f65cbebf3}</Project>
       <Name>RemoteWorkspaces</Name>
diff --git a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs
index b20973b68810b..606727142b5cf 100644
--- a/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs
+++ b/src/ExpressionEvaluator/Core/Test/ExpressionCompiler/ExpressionCompilerTestHelpers.cs
@@ -27,7 +27,6 @@
 using Microsoft.VisualStudio.Debugger.Evaluation.ClrCompilation;
 using Roslyn.Test.Utilities;
 using Xunit;
-using PDB::Roslyn.Test.MetadataUtilities;
 using PDB::Roslyn.Test.PdbUtilities;
 
 namespace Microsoft.CodeAnalysis.ExpressionEvaluator.UnitTests
diff --git a/src/Test/PdbUtilities/Metadata/MethodILExtensions.cs b/src/Test/PdbUtilities/Metadata/MethodILExtensions.cs
deleted file mode 100644
index fb08336ab4f80..0000000000000
--- a/src/Test/PdbUtilities/Metadata/MethodILExtensions.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Reflection.Metadata;
-using System.Text;
-using Microsoft.Metadata.Tools;
-
-namespace Roslyn.Test.MetadataUtilities
-{
-    public static class MethodILExtensions
-    {
-        public static unsafe string GetMethodIL(this ImmutableArray<byte> ilArray)
-        {
-            var result = new StringBuilder();
-            fixed (byte* ilPtr = ilArray.ToArray())
-            {
-                int offset = 0;
-                while (true)
-                {
-                    // skip padding:
-                    while (offset < ilArray.Length && ilArray[offset] == 0)
-                    {
-                        offset++;
-                    }
-
-                    if (offset == ilArray.Length)
-                    {
-                        break;
-                    }
-
-                    var reader = new BlobReader(ilPtr + offset, ilArray.Length - offset);
-                    var methodIL = MethodBodyBlock.Create(reader);
-
-                    if (methodIL == null)
-                    {
-                        result.AppendFormat("<invalid byte 0x{0:X2} at offset {1}>", ilArray[offset], offset);
-                        offset++;
-                    }
-                    else
-                    {
-                        ILVisualizer.Default.DumpMethod(
-                            result,
-                            methodIL.MaxStack,
-                            methodIL.GetILContent(),
-                            ImmutableArray.Create<ILVisualizer.LocalInfo>(),
-                            ImmutableArray.Create<ILVisualizer.HandlerSpan>());
-
-                        offset += methodIL.Size;
-                    }
-                }
-            }
-
-            return result.ToString();
-        }
-    }
-}
diff --git a/src/Test/Utilities/Portable/Pdb/MockSymWriter.cs b/src/Test/PdbUtilities/Pdb/MockSymWriter.cs
similarity index 100%
rename from src/Test/Utilities/Portable/Pdb/MockSymWriter.cs
rename to src/Test/PdbUtilities/Pdb/MockSymWriter.cs
diff --git a/src/Test/Utilities/Portable/Pdb/PdbTestUtilities.cs b/src/Test/PdbUtilities/Pdb/PdbTestUtilities.cs
similarity index 98%
rename from src/Test/Utilities/Portable/Pdb/PdbTestUtilities.cs
rename to src/Test/PdbUtilities/Pdb/PdbTestUtilities.cs
index d5958ebc34de4..2d3d86529835e 100644
--- a/src/Test/Utilities/Portable/Pdb/PdbTestUtilities.cs
+++ b/src/Test/PdbUtilities/Pdb/PdbTestUtilities.cs
@@ -15,7 +15,7 @@
 
 namespace Roslyn.Test.Utilities
 {
-    internal static class PdbTestUtilities
+    public static class PdbTestUtilities
     {
         public static ISymUnmanagedReader3 CreateSymReader(this CompilationVerifier verifier)
         {
diff --git a/src/Test/Utilities/Portable/Pdb/PdbValidation.cs b/src/Test/PdbUtilities/Pdb/PdbValidation.cs
similarity index 99%
rename from src/Test/Utilities/Portable/Pdb/PdbValidation.cs
rename to src/Test/PdbUtilities/Pdb/PdbValidation.cs
index 70e78b94bd501..802c163c2f098 100644
--- a/src/Test/Utilities/Portable/Pdb/PdbValidation.cs
+++ b/src/Test/PdbUtilities/Pdb/PdbValidation.cs
@@ -131,7 +131,7 @@ private static void VerifyPdb(
             AssertXml.Equal(expectedXml, actualXml, $"Format: {format}{Environment.NewLine}", expectedValueSourcePath, expectedValueSourceLine, expectedIsXmlLiteral);
         }
 
-        internal static void VerifyPdb(
+        public static void VerifyPdb(
             this Compilation compilation,
             string expectedPdb,
             IMethodSymbol debugEntryPoint = null,
@@ -143,7 +143,7 @@ internal static void VerifyPdb(
             VerifyPdb(compilation, "", expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
         }
 
-        internal static void VerifyPdb(
+        public static void VerifyPdb(
             this Compilation compilation,
             string qualifiedMethodName,
             string expectedPdb,
@@ -165,7 +165,7 @@ internal static void VerifyPdb(
                 expectedIsXmlLiteral: false);
         }
 
-        internal static void VerifyPdb(
+        public static void VerifyPdb(
             this Compilation compilation,
             XElement expectedPdb,
             IMethodSymbol debugEntryPoint = null,
@@ -177,7 +177,7 @@ internal static void VerifyPdb(
             VerifyPdb(compilation, "", expectedPdb, debugEntryPoint, format, options, expectedValueSourceLine, expectedValueSourcePath);
         }
 
-        internal static void VerifyPdb(
+        public static void VerifyPdb(
             this Compilation compilation,
             string qualifiedMethodName,
             XElement expectedPdb,
diff --git a/src/Test/PdbUtilities/PdbUtilities.csproj b/src/Test/PdbUtilities/PdbUtilities.csproj
index 1bd72d0917d5d..25aa598910692 100644
--- a/src/Test/PdbUtilities/PdbUtilities.csproj
+++ b/src/Test/PdbUtilities/PdbUtilities.csproj
@@ -11,6 +11,7 @@
     <RootNamespace>Roslyn.Test.PdbUtilities</RootNamespace>
     <AssemblyName>Roslyn.Test.PdbUtilities</AssemblyName>
     <TargetFramework>netstandard1.3</TargetFramework>
+    <PackageTargetFallback>portable-net452</PackageTargetFallback>
     <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
@@ -18,18 +19,10 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'" />
   <ItemGroup Label="Linked Files">
-    <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\ExceptionUtilities.cs">
-      <Link>InternalUtilities\ExceptionUtilities.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\Hash.cs">
-      <Link>InternalUtilities\Hash.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\StreamExtensions.cs">
-      <Link>InternalUtilities\StreamExtensions.cs</Link>
-    </Compile>
-    <Compile Include="Metadata\AggregatedMetadataReader.cs" />
-    <Compile Include="Metadata\MethodILExtensions.cs" />
     <Compile Include="Pdb\CustomDebugInfoUtilities.cs" />
+    <Compile Include="Pdb\MockSymWriter.cs" />
+    <Compile Include="Pdb\PdbTestUtilities.cs" />
+    <Compile Include="Pdb\PdbValidation.cs" />
     <Compile Include="Pdb\SymReaderFactory.cs" />
     <Compile Include="Pdb\Token2SourceLineExporter.cs" />
     <Compile Include="Shared\DateTimeUtilities.cs" />
@@ -37,20 +30,46 @@
     <Compile Include="Shared\StringUtilities.cs" />
   </ItemGroup>
   <ItemGroup>
+    <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.CommandLine.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.Emit.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.WinRT.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.PerformanceTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.Semantic.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.Symbol.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.Syntax.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.Test.Utilities" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.Test.Utilities.Desktop" />
     <InternalsVisibleToTest Include="Roslyn.Compilers.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.VisualBasic.CommandLine.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.VisualBasic.Emit.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.VisualBasic.EnC.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.VisualBasic.PerformanceTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.VisualBasic.Semantic.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.VisualBasic.Symbol.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.VisualBasic.Syntax.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Compilers.VisualBasic.Test.Utilities" />
+    <InternalsVisibleToTest Include="Roslyn.ExpressionEvaluator.CSharp.ExpressionCompiler.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.ExpressionEvaluator.CSharp.ResultProvider.UnitTests" />
     <InternalsVisibleToTest Include="Roslyn.ExpressionEvaluator.ExpressionCompiler.Test.Utilities" />
+    <InternalsVisibleToTest Include="Roslyn.ExpressionEvaluator.FunctionResolver.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.ExpressionEvaluator.VisualBasic.ExpressionCompiler.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.ExpressionEvaluator.VisualBasic.ResultProvider.UnitTests" />
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.DiaSymReader.Native" Version="$(MicrosoftDiaSymReaderNativeVersion)" />
     <PackageReference Include="Microsoft.DiaSymReader" Version="$(MicrosoftDiaSymReaderVersion)" />
     <PackageReference Include="Microsoft.DiaSymReader.PortablePdb" Version="$(MicrosoftDiaSymReaderPortablePdbVersion)" />
+    <PackageReference Include="Microsoft.DiaSymReader.Converter.Xml" Version="$(MicrosoftDiaSymReaderConverterXmlVersion)" />
     <PackageReference Include="Microsoft.Metadata.Visualizer" Version="$(MicrosoftMetadataVisualizerVersion)" />
     <PackageReference Include="System.Collections.Immutable" Version="$(SystemCollectionsImmutableVersion)" />
     <PackageReference Include="System.Reflection.Metadata" Version="$(SystemReflectionMetadataVersion)" />
     <PackageReference Include="System.Xml.ReaderWriter" Version="$(SystemXmlReaderWriterVersion)" />
     <PackageReference Include="System.ValueTuple" Version="$(SystemValueTupleVersion)" />
+    <PackageReference Include="xunit.assert" Version="$(xunitVersion)" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Compilers\Core\Portable\CodeAnalysis.csproj" />
+    <ProjectReference Include="..\Utilities\Portable\TestUtilities.csproj" />
   </ItemGroup>
-  <Import Project="..\..\Dependencies\PooledObjects\Microsoft.CodeAnalysis.PooledObjects.projitems" Label="Shared" />
-  <Import Project="..\..\Dependencies\CodeAnalysis.Metadata\Microsoft.CodeAnalysis.Metadata.projitems" Label="Shared" />
   <Import Project="..\..\..\build\Targets\Imports.targets" />
 </Project>
\ No newline at end of file
diff --git a/src/Test/Utilities/CoreClr/TestUtilities.CoreClr.csproj b/src/Test/Utilities/CoreClr/TestUtilities.CoreClr.csproj
index c6a95ca6234bd..b3b864f199ad1 100644
--- a/src/Test/Utilities/CoreClr/TestUtilities.CoreClr.csproj
+++ b/src/Test/Utilities/CoreClr/TestUtilities.CoreClr.csproj
@@ -22,10 +22,6 @@
       <Project>{7fe6b002-89d8-4298-9b1b-0b5c247dd1fd}</Project>
       <Name>CompilerTestResources</Name>
     </ProjectReference>
-    <ProjectReference Include="..\..\PdbUtilities\PdbUtilities.csproj">
-      <Project>{afde6bea-5038-4a4a-a88e-dbd2e4088eed}</Project>
-      <Name>PdbUtilities</Name>
-    </ProjectReference>
     <ProjectReference Include="..\..\..\Compilers\Core\Portable\CodeAnalysis.csproj">
       <Project>{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}</Project>
       <Name>CodeAnalysis</Name>
diff --git a/src/Test/Utilities/Desktop/TestUtilities.Desktop.csproj b/src/Test/Utilities/Desktop/TestUtilities.Desktop.csproj
index 711f600c82e62..2e515d5011279 100644
--- a/src/Test/Utilities/Desktop/TestUtilities.Desktop.csproj
+++ b/src/Test/Utilities/Desktop/TestUtilities.Desktop.csproj
@@ -31,10 +31,6 @@
       <Project>{2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}</Project>
       <Name>BasicCodeAnalysis</Name>
     </ProjectReference>
-    <ProjectReference Include="..\..\PdbUtilities\PdbUtilities.csproj">
-      <Project>{afde6bea-5038-4a4a-a88e-dbd2e4088eed}</Project>
-      <Name>PdbUtilities</Name>
-    </ProjectReference>
     <ProjectReference Include="..\Portable\TestUtilities.csproj">
       <Project>{ccbd3438-3e84-40a9-83ad-533f23bcfca5}</Project>
       <Name>TestUtilities</Name>
diff --git a/src/Test/Utilities/Portable/Compilation/CompilationDifference.cs b/src/Test/Utilities/Portable/Compilation/CompilationDifference.cs
index ac45563dd2bc8..6fc9329c461a3 100644
--- a/src/Test/Utilities/Portable/Compilation/CompilationDifference.cs
+++ b/src/Test/Utilities/Portable/Compilation/CompilationDifference.cs
@@ -12,7 +12,6 @@
 using Microsoft.CodeAnalysis.Emit;
 using Microsoft.DiaSymReader.Tools;
 using Microsoft.Metadata.Tools;
-using Roslyn.Test.MetadataUtilities;
 using Roslyn.Test.Utilities;
 
 namespace Microsoft.CodeAnalysis.Test.Utilities
diff --git a/src/Test/Utilities/Portable/CompilationVerifier.cs b/src/Test/Utilities/Portable/CompilationVerifier.cs
index a43bce9f07e29..d47fbab8aa982 100644
--- a/src/Test/Utilities/Portable/CompilationVerifier.cs
+++ b/src/Test/Utilities/Portable/CompilationVerifier.cs
@@ -25,8 +25,8 @@ public sealed class CompilationVerifier
         private IModuleSymbol _lazyModuleSymbol;
         private IList<ModuleData> _allModuleData;
 
-        internal ImmutableArray<byte> EmittedAssemblyData;
-        internal ImmutableArray<byte> EmittedAssemblyPdb;
+        public ImmutableArray<byte> EmittedAssemblyData;
+        public ImmutableArray<byte> EmittedAssemblyPdb;
 
         private readonly Func<IModuleSymbol, CompilationTestData.MethodData, IReadOnlyDictionary<int, string>, string> _visualizeRealIL;
 
diff --git a/src/Test/PdbUtilities/Metadata/AggregatedMetadataReader.cs b/src/Test/Utilities/Portable/Metadata/AggregatedMetadataReader.cs
similarity index 100%
rename from src/Test/PdbUtilities/Metadata/AggregatedMetadataReader.cs
rename to src/Test/Utilities/Portable/Metadata/AggregatedMetadataReader.cs
diff --git a/src/Test/Utilities/Portable/Metadata/ILValidation.cs b/src/Test/Utilities/Portable/Metadata/ILValidation.cs
new file mode 100644
index 0000000000000..949dddb3aad76
--- /dev/null
+++ b/src/Test/Utilities/Portable/Metadata/ILValidation.cs
@@ -0,0 +1,186 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Reflection.Metadata;
+using System.Text;
+using System.Xml;
+using Microsoft.Metadata.Tools;
+
+namespace Roslyn.Test.Utilities
+{
+    public static class ILValidation
+    {
+        public static unsafe string GetMethodIL(this ImmutableArray<byte> ilArray)
+        {
+            var result = new StringBuilder();
+            fixed (byte* ilPtr = ilArray.ToArray())
+            {
+                int offset = 0;
+                while (true)
+                {
+                    // skip padding:
+                    while (offset < ilArray.Length && ilArray[offset] == 0)
+                    {
+                        offset++;
+                    }
+
+                    if (offset == ilArray.Length)
+                    {
+                        break;
+                    }
+
+                    var reader = new BlobReader(ilPtr + offset, ilArray.Length - offset);
+                    var methodIL = MethodBodyBlock.Create(reader);
+
+                    if (methodIL == null)
+                    {
+                        result.AppendFormat("<invalid byte 0x{0:X2} at offset {1}>", ilArray[offset], offset);
+                        offset++;
+                    }
+                    else
+                    {
+                        ILVisualizer.Default.DumpMethod(
+                            result,
+                            methodIL.MaxStack,
+                            methodIL.GetILContent(),
+                            ImmutableArray.Create<ILVisualizer.LocalInfo>(),
+                            ImmutableArray.Create<ILVisualizer.HandlerSpan>());
+
+                        offset += methodIL.Size;
+                    }
+                }
+            }
+
+            return result.ToString();
+        }
+
+        public static Dictionary<int, string> GetSequencePointMarkers(string pdbXml, string source = null)
+        {
+            string[] lines = source?.Split(new[] { "\r\n" }, StringSplitOptions.None);
+            var doc = new XmlDocument();
+            doc.LoadXml(pdbXml);
+            var result = new Dictionary<int, string>();
+
+            if (source == null)
+            {
+                foreach (XmlNode entry in doc.GetElementsByTagName("sequencePoints"))
+                {
+                    foreach (XmlElement item in entry.ChildNodes)
+                    {
+                        Add(result,
+                            Convert.ToInt32(item.GetAttribute("offset"), 16),
+                            (item.GetAttribute("hidden") == "true") ? "~" : "-");
+                    }
+                }
+
+                foreach (XmlNode entry in doc.GetElementsByTagName("asyncInfo"))
+                {
+                    foreach (XmlElement item in entry.ChildNodes)
+                    {
+                        if (item.Name == "await")
+                        {
+                            Add(result, Convert.ToInt32(item.GetAttribute("yield"), 16), "<");
+                            Add(result, Convert.ToInt32(item.GetAttribute("resume"), 16), ">");
+                        }
+                        else if (item.Name == "catchHandler")
+                        {
+                            Add(result, Convert.ToInt32(item.GetAttribute("offset"), 16), "$");
+                        }
+                    }
+                }
+            }
+            else
+            {
+                foreach (XmlNode entry in doc.GetElementsByTagName("asyncInfo"))
+                {
+                    foreach (XmlElement item in entry.ChildNodes)
+                    {
+                        if (item.Name == "await")
+                        {
+                            AddTextual(result, Convert.ToInt32(item.GetAttribute("yield"), 16), "async: yield");
+                            AddTextual(result, Convert.ToInt32(item.GetAttribute("resume"), 16), "async: resume");
+                        }
+                        else if (item.Name == "catchHandler")
+                        {
+                            AddTextual(result, Convert.ToInt32(item.GetAttribute("offset"), 16), "async: catch handler");
+                        }
+                    }
+                }
+
+                foreach (XmlNode entry in doc.GetElementsByTagName("sequencePoints"))
+                {
+                    foreach (XmlElement item in entry.ChildNodes)
+                    {
+                        AddTextual(result, Convert.ToInt32(item.GetAttribute("offset"), 16), "sequence point: " + SnippetFromSpan(lines, item));
+                    }
+                }
+            }
+
+            return result;
+
+            void Add(Dictionary<int, string> dict, int key, string value)
+            {
+                if (dict.TryGetValue(key, out string found))
+                {
+                    dict[key] = found + value;
+                }
+                else
+                {
+                    dict[key] = value;
+                }
+            }
+
+            void AddTextual(Dictionary<int, string> dict, int key, string value)
+            {
+                if (dict.TryGetValue(key, out string found))
+                {
+                    dict[key] = found + ", " + value;
+                }
+                else
+                {
+                    dict[key] = "// " + value;
+                }
+            }
+        }
+
+        private static string SnippetFromSpan(string[] lines, XmlElement span)
+        {
+            if (span.GetAttribute("hidden") != "true")
+            {
+                var startLine = Convert.ToInt32(span.GetAttribute("startLine"));
+                var startColumn = Convert.ToInt32(span.GetAttribute("startColumn"));
+                var endLine = Convert.ToInt32(span.GetAttribute("endLine"));
+                var endColumn = Convert.ToInt32(span.GetAttribute("endColumn"));
+                if (startLine == endLine)
+                {
+                    return lines[startLine - 1].Substring(startColumn - 1, endColumn - startColumn);
+                }
+                else
+                {
+                    var start = lines[startLine - 1].Substring(startColumn - 1);
+                    var end = lines[endLine - 1].Substring(0, endColumn - 1);
+                    return TruncateStart(start, 12) + " ... " + TruncateEnd(end, 12);
+                }
+            }
+            else
+            {
+                return "<hidden>";
+            }
+
+            string TruncateStart(string text, int maxLength)
+            {
+                if (text.Length < maxLength) { return text; }
+                return text.Substring(0, maxLength);
+            }
+
+            string TruncateEnd(string text, int maxLength)
+            {
+                if (text.Length < maxLength) { return text; }
+                return text.Substring(text.Length - maxLength - 1, maxLength);
+            }
+        }
+    }
+}
diff --git a/src/Test/Utilities/Portable/Metadata/MetadataSignatureUnitTestHelper.cs b/src/Test/Utilities/Portable/Metadata/MetadataSignatureUnitTestHelper.cs
new file mode 100644
index 0000000000000..dd2308fc6fa89
--- /dev/null
+++ b/src/Test/Utilities/Portable/Metadata/MetadataSignatureUnitTestHelper.cs
@@ -0,0 +1,170 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis.Text;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Test.Utilities
+{
+    internal class MetadataSignatureUnitTestHelper
+    {
+        /// <summary>
+        /// Uses Reflection to verify that the specified member signatures are present in emitted metadata
+        /// </summary>
+        /// <param name="appDomainHost">Unit test AppDomain host</param>
+        /// <param name="expectedSignatures">Baseline signatures - use the Signature() factory method to create instances of SignatureDescription</param>
+        internal static void VerifyMemberSignatures(
+            IRuntimeEnvironment appDomainHost, params SignatureDescription[] expectedSignatures)
+        {
+            Assert.NotNull(expectedSignatures);
+            Assert.NotEmpty(expectedSignatures);
+
+            var succeeded = true;
+            var expected = new List<string>();
+            var actual = new List<string>();
+
+            foreach (var signature in expectedSignatures)
+            {
+                List<string> actualSignatures = null;
+                var expectedSignature = signature.ExpectedSignature;
+
+                if (!VerifyMemberSignatureHelper(
+                    appDomainHost, signature.FullyQualifiedTypeName, signature.MemberName,
+                    ref expectedSignature, out actualSignatures))
+                {
+                    succeeded = false;
+                }
+
+                expected.Add(expectedSignature);
+                actual.AddRange(actualSignatures);
+            }
+
+            if (!succeeded)
+            {
+                TriggerSignatureMismatchFailure(expected, actual);
+            }
+        }
+
+        /// <summary>
+        /// Uses Reflection to verify that the specified member signature is present in emitted metadata
+        /// </summary>
+        /// <param name="appDomainHost">Unit test AppDomain host</param>
+        /// <param name="fullyQualifiedTypeName">
+        /// Fully qualified type name for member
+        /// Names must be in format recognized by reflection
+        /// e.g. MyType&lt;T&gt;.MyNestedType&lt;T, U&gt; => MyType`1+MyNestedType`2
+        /// </param>
+        /// <param name="memberName">
+        /// Name of member on specified type whose signature needs to be verified
+        /// Names must be in format recognized by reflection
+        /// e.g. For explicitly implemented member - I1&lt;string&gt;.Method => I1&lt;System.String&gt;.Method
+        /// </param>
+        /// <param name="expectedSignature">
+        /// Baseline string for signature of specified member
+        /// Skip this argument to get an error message that shows all available signatures for specified member
+        /// This argument is passed by reference and it will be updated with a formatted form of the baseline signature for error reporting purposes
+        /// </param>
+        /// <param name="actualSignatures">List of found signatures matching member name</param>
+        /// <returns>True if a matching member signature was found, false otherwise</returns>
+        private static bool VerifyMemberSignatureHelper(
+            IRuntimeEnvironment appDomainHost, string fullyQualifiedTypeName, string memberName,
+            ref string expectedSignature, out List<string> actualSignatures)
+        {
+            Assert.False(string.IsNullOrWhiteSpace(fullyQualifiedTypeName), "'fullyQualifiedTypeName' can't be null or empty");
+            Assert.False(string.IsNullOrWhiteSpace(memberName), "'memberName' can't be null or empty");
+
+            var retVal = true; actualSignatures = new List<string>();
+            var signatures = appDomainHost.GetMemberSignaturesFromMetadata(fullyQualifiedTypeName, memberName);
+            var signatureAssertText = "Signature(\"" + fullyQualifiedTypeName + "\", \"" + memberName + "\", \"{0}\"),";
+
+            if (!string.IsNullOrWhiteSpace(expectedSignature))
+            {
+                expectedSignature = expectedSignature.Replace("\"", "\\\"");
+            }
+            expectedSignature = string.Format(signatureAssertText, expectedSignature);
+
+            if (signatures.Count > 1)
+            {
+                var found = false;
+                foreach (var signature in signatures)
+                {
+                    var actualSignature = signature.Replace("\"", "\\\"");
+                    actualSignature = string.Format(signatureAssertText, actualSignature);
+
+                    if (actualSignature == expectedSignature)
+                    {
+                        actualSignatures.Clear();
+                        actualSignatures.Add(actualSignature);
+                        found = true; break;
+                    }
+                    else
+                    {
+                        actualSignatures.Add(actualSignature);
+                    }
+                }
+                if (!found)
+                {
+                    retVal = false;
+                }
+            }
+            else if (signatures.Count == 1)
+            {
+                var actualSignature = signatures.First().Replace("\"", "\\\"");
+                actualSignature = string.Format(signatureAssertText, actualSignature);
+                actualSignatures.Add(actualSignature);
+
+                if (expectedSignature != actualSignature)
+                {
+                    retVal = false;
+                }
+            }
+            else
+            {
+                retVal = false;
+            }
+
+            return retVal;
+        }
+
+        /// <summary>
+        /// Triggers assert when expected and actual signatures don't match
+        /// </summary>
+        /// <param name="expectedSignatures">List of baseline signature strings</param>
+        /// <param name="actualSignatures">List of actually found signature strings</param>
+        private static void TriggerSignatureMismatchFailure(List<string> expectedSignatures, List<string> actualSignatures)
+        {
+            var expectedText = string.Empty;
+            var actualText = string.Empty;
+            var distinctSignatures = new HashSet<string>();
+
+            foreach (var signature in expectedSignatures)
+            {
+                // We need to preserve the order as well as prevent duplicates
+                if (!distinctSignatures.Contains(signature))
+                {
+                    expectedText += "\n\t" + signature;
+                    distinctSignatures.Add(signature);
+                }
+            }
+
+            distinctSignatures.Clear();
+            foreach (var signature in actualSignatures)
+            {
+                // We need to preserve the order as well as prevent duplicates
+                if (!distinctSignatures.Contains(signature))
+                {
+                    actualText += "\n\t" + signature;
+                    distinctSignatures.Add(signature);
+                }
+            }
+
+            expectedText = expectedText.TrimEnd(',');
+            actualText = actualText.TrimEnd(',');
+            var diffText = DiffUtil.DiffReport(expectedText, actualText);
+
+            Assert.True(false, "\n\nExpected:" + expectedText + "\n\nActual:" + actualText + "\n\nDifferences:\n" + diffText);
+        }
+    }
+}
diff --git a/src/Test/Utilities/Portable/TestUtilities.csproj b/src/Test/Utilities/Portable/TestUtilities.csproj
index 7d19457774576..4ac38ce066ea1 100644
--- a/src/Test/Utilities/Portable/TestUtilities.csproj
+++ b/src/Test/Utilities/Portable/TestUtilities.csproj
@@ -22,10 +22,6 @@
       <Project>{7fe6b002-89d8-4298-9b1b-0b5c247dd1fd}</Project>
       <Name>CompilerTestResources</Name>
     </ProjectReference>
-    <ProjectReference Include="..\..\PdbUtilities\PdbUtilities.csproj">
-      <Project>{afde6bea-5038-4a4a-a88e-dbd2e4088eed}</Project>
-      <Name>PdbUtilities</Name>
-    </ProjectReference>
     <ProjectReference Include="..\..\..\Compilers\Core\Portable\CodeAnalysis.csproj">
       <Project>{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}</Project>
       <Name>CodeAnalysis</Name>
@@ -47,7 +43,6 @@
     <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.CommandLine.UnitTests" />
     <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.Emit.UnitTests" />
     <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.WinRT.UnitTests" />
-    <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.EnC.UnitTests" />
     <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.PerformanceTests" />
     <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.Semantic.UnitTests" />
     <InternalsVisibleToTest Include="Roslyn.Compilers.CSharp.Symbol.UnitTests" />
@@ -138,7 +133,7 @@
     <Compile Include="FX\EncodingUtilities.cs" />
     <Compile Include="FX\EnsureEnglishUICulture.cs" />
     <Compile Include="FX\EnsureInvariantCulture.cs" />
-    <Compile Include="FX\EventWaiter.cs" />    
+    <Compile Include="FX\EventWaiter.cs" />
     <Compile Include="FX\HResult.cs" />
     <Compile Include="FX\ImmutableArrayTestExtensions.cs" />
     <Compile Include="FX\MonoHelpers.cs" />
@@ -151,6 +146,7 @@
     <Compile Include="ICompilationVerifier.cs" />
     <Compile Include="MarkedSource\MarkupTestFile.cs" />
     <Compile Include="MarkedSource\SourceWithMarkedNodes.cs" />
+    <Compile Include="Metadata\AggregatedMetadataReader.cs" />
     <Compile Include="Metadata\MetadataSignatureUnitTestHelper.cs" />
     <Compile Include="Metadata\CustomAttributeRow.cs" />
     <Compile Include="Metadata\DynamicAnalysisDataReader.cs" />
@@ -174,9 +170,6 @@
     <Compile Include="Mocks\TestStream.cs" />
     <Compile Include="Mocks\VirtualizedRelativePathResolver.cs" />
     <Compile Include="ObjectReference.cs" />
-    <Compile Include="Pdb\MockSymWriter.cs" />
-    <Compile Include="Pdb\PdbTestUtilities.cs" />
-    <Compile Include="Pdb\PdbValidation.cs" />
     <Compile Include="Pe\BrokenStream.cs" />
     <Compile Include="ReflectionAssert.cs" />
     <Compile Include="Syntax\ISyntaxNodeKindProvider.cs" />
diff --git a/src/VisualStudio/Core/Test.Next/VisualStudioTest.Next.csproj b/src/VisualStudio/Core/Test.Next/VisualStudioTest.Next.csproj
index b076f92a0ab82..89ad3a6d312a6 100644
--- a/src/VisualStudio/Core/Test.Next/VisualStudioTest.Next.csproj
+++ b/src/VisualStudio/Core/Test.Next/VisualStudioTest.Next.csproj
@@ -143,10 +143,6 @@
       <Project>{eba4dfa1-6ded-418f-a485-a3b608978906}</Project>
       <Name>InteractiveHost</Name>
     </ProjectReference>
-    <ProjectReference Include="..\..\..\Test\PdbUtilities\PdbUtilities.csproj">
-      <Project>{afde6bea-5038-4a4a-a88e-dbd2e4088eed}</Project>
-      <Name>PdbUtilities</Name>
-    </ProjectReference>
     <ProjectReference Include="..\..\..\Scripting\Core\Scripting.csproj">
       <Project>{12a68549-4e8c-42d6-8703-a09335f97997}</Project>
       <Name>Scripting</Name>

From 4b848b87c319419558179f4b23351e6596be11f7 Mon Sep 17 00:00:00 2001
From: Paul Vick <paulvick@hotmail.com>
Date: Mon, 15 May 2017 13:58:21 -0700
Subject: [PATCH 234/284] Fix FQN for CodeLens

---
 .../CodeLens/CSharpCodeLensTests.cs           | 36 ++++++++++++
 .../CodeLens/AbstractCodeLensTest.cs          | 29 ++++++++++
 .../CodeLens/CodeLensReferencesService.cs     | 56 ++++++++++++++++++-
 .../Portable/MarkedSource/MarkupTestFile.cs   |  2 +-
 4 files changed, 121 insertions(+), 2 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/CodeLens/CSharpCodeLensTests.cs b/src/EditorFeatures/CSharpTest/CodeLens/CSharpCodeLensTests.cs
index b1014406b4e3d..fc163a65b09f8 100644
--- a/src/EditorFeatures/CSharpTest/CodeLens/CSharpCodeLensTests.cs
+++ b/src/EditorFeatures/CSharpTest/CodeLens/CSharpCodeLensTests.cs
@@ -176,5 +176,41 @@ public class A
 </Workspace>";
             await RunMethodReferenceTest(input);
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeLens)]
+        public async Task TestFullyQualifiedName()
+        {
+            const string input = @"<Workspace>
+    <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""Proj1"">
+        <Document FilePath=""CurrentDocument.cs""><![CDATA[
+public class A
+{
+    {|A.C: public void C()
+    {
+        C();
+    }|}
+
+    public class B
+    {
+        {|A+B.C: public void C()
+        {
+            C();
+        }|}
+
+        public class D
+        {
+            {|A+B+D.C: public void C()
+            {
+                C();
+            }|}
+        }
+    }
+}
+]]>
+        </Document>
+    </Project>
+</Workspace>";
+            await RunFullyQualifiedNameTest(input);
+        }
     }
 }
diff --git a/src/EditorFeatures/TestUtilities/CodeLens/AbstractCodeLensTest.cs b/src/EditorFeatures/TestUtilities/CodeLens/AbstractCodeLensTest.cs
index c1855be983443..d509129a52a64 100644
--- a/src/EditorFeatures/TestUtilities/CodeLens/AbstractCodeLensTest.cs
+++ b/src/EditorFeatures/TestUtilities/CodeLens/AbstractCodeLensTest.cs
@@ -103,5 +103,34 @@ protected static Task RunMethodReferenceTest(string input)
         {
             return RunMethodReferenceTest(XElement.Parse(input));
         }
+
+        protected static async Task RunFullyQualifiedNameTest(XElement input)
+        {
+            using (var workspace = await TestWorkspace.CreateAsync(input))
+            {
+                foreach (var annotatedDocument in workspace.Documents.Where(d => d.AnnotatedSpans.Any()))
+                {
+                    var document = workspace.CurrentSolution.GetDocument(annotatedDocument.Id);
+                    var syntaxNode = await document.GetSyntaxRootAsync();
+                    foreach (var annotatedSpan in annotatedDocument.AnnotatedSpans)
+                    {
+                        var expected = annotatedSpan.Key;
+
+                        foreach (var span in annotatedSpan.Value)
+                        {
+                            var declarationSyntaxNode = syntaxNode.FindNode(span);
+                            var actual = await new CodeLensReferencesService().GetFullyQualifiedName(workspace.CurrentSolution,
+                                annotatedDocument.Id, declarationSyntaxNode, CancellationToken.None);
+                            Assert.Equal(expected, actual);
+                        }
+                    }
+                }
+            }
+        }
+
+        protected static Task RunFullyQualifiedNameTest(string input)
+        {
+            return RunFullyQualifiedNameTest(XElement.Parse(input));
+        }
     }
 }
diff --git a/src/Features/Core/Portable/CodeLens/CodeLensReferencesService.cs b/src/Features/Core/Portable/CodeLens/CodeLensReferencesService.cs
index e1bb41f366248..a0df42cc37067 100644
--- a/src/Features/Core/Portable/CodeLens/CodeLensReferencesService.cs
+++ b/src/Features/Core/Portable/CodeLens/CodeLensReferencesService.cs
@@ -4,8 +4,10 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.FindSymbols;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -268,8 +270,60 @@ public async Task<string> GetFullyQualifiedName(Solution solution, DocumentId do
             using (solution.Services.CacheService?.EnableCaching(document.Project.Id))
             {
                 var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+                var declaredSymbol = semanticModel.GetDeclaredSymbol(syntaxNode, cancellationToken);
 
-                return semanticModel.GetDeclaredSymbol(syntaxNode, cancellationToken)?.ToDisplayString(MethodDisplayFormat);
+                if (declaredSymbol == null)
+                {
+                    return string.Empty;
+                }
+
+                var parts = declaredSymbol.ToDisplayParts(MethodDisplayFormat);
+                var pool = PooledStringBuilder.GetInstance();
+
+                try
+                {
+                    var actualBuilder = pool.Builder;
+                    var previousWasClass = false;
+
+                    for (var index = 0; index < parts.Length; index++)
+                    {
+                        var part = parts[index];
+                        if (previousWasClass && 
+                            part.Kind == SymbolDisplayPartKind.Punctuation &&
+                            index < parts.Length - 1)
+                        {
+                            switch (parts[index + 1].Kind)
+                            {
+                                case SymbolDisplayPartKind.ClassName:
+                                case SymbolDisplayPartKind.DelegateName:
+                                case SymbolDisplayPartKind.EnumName:
+                                case SymbolDisplayPartKind.ErrorTypeName:
+                                case SymbolDisplayPartKind.InterfaceName:
+                                case SymbolDisplayPartKind.StructName:
+                                    actualBuilder.Append('+');
+                                    break;
+
+                                default:
+                                    actualBuilder.Append(part);
+                                    break;
+                            }
+                        }
+                        else
+                        {
+                            actualBuilder.Append(part);
+                        }
+
+                        previousWasClass = part.Kind == SymbolDisplayPartKind.ClassName ||
+                                           part.Kind == SymbolDisplayPartKind.InterfaceName ||
+                                           part.Kind == SymbolDisplayPartKind.StructName;
+                    }
+
+                    return actualBuilder.ToString();
+                }
+                finally
+                {
+                    pool.Free();
+                }
             }
         }
     }
diff --git a/src/Test/Utilities/Portable/MarkedSource/MarkupTestFile.cs b/src/Test/Utilities/Portable/MarkedSource/MarkupTestFile.cs
index 0e0517bee16da..e4d88cda3c1f4 100644
--- a/src/Test/Utilities/Portable/MarkedSource/MarkupTestFile.cs
+++ b/src/Test/Utilities/Portable/MarkedSource/MarkupTestFile.cs
@@ -40,7 +40,7 @@ public static class MarkupTestFile
         private const string NamedSpanStartString = "{|";
         private const string NamedSpanEndString = "|}";
 
-        private static readonly Regex s_namedSpanStartRegex = new Regex(@"\{\| ([-_.A-Za-z0-9]+) \:",
+        private static readonly Regex s_namedSpanStartRegex = new Regex(@"\{\| ([-_.A-Za-z0-9\+]+) \:",
             RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace);
 
         private static void Parse(string input, out string output, out int? position, out IDictionary<string, IList<TextSpan>> spans)

From e758647b021f004d2366969db6fee8a08f0b29c6 Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam.harwell@microsoft.com>
Date: Sat, 13 May 2017 18:22:01 -0500
Subject: [PATCH 235/284] Rename file to match contained type name

---
 ...es.cs => TemporaryStorageServiceFactory.MemoryMappedInfo.cs} | 0
 src/Workspaces/Core/Desktop/Workspaces.Desktop.csproj           | 2 +-
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/{TemporaryStorageServiceFactory.MemoryMappedFiles.cs => TemporaryStorageServiceFactory.MemoryMappedInfo.cs} (100%)

diff --git a/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.MemoryMappedFiles.cs b/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.MemoryMappedInfo.cs
similarity index 100%
rename from src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.MemoryMappedFiles.cs
rename to src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.MemoryMappedInfo.cs
diff --git a/src/Workspaces/Core/Desktop/Workspaces.Desktop.csproj b/src/Workspaces/Core/Desktop/Workspaces.Desktop.csproj
index 7429d730ff80c..ac315231d59e0 100644
--- a/src/Workspaces/Core/Desktop/Workspaces.Desktop.csproj
+++ b/src/Workspaces/Core/Desktop/Workspaces.Desktop.csproj
@@ -96,7 +96,7 @@
     <Compile Include="Workspace\Host\Mef\MefV1HostServices.cs" />
     <Compile Include="Workspace\Host\SimpleAnalyzerAssemblyLoaderService.cs" />
     <Compile Include="Workspace\Host\TemporaryStorage\TemporaryStorageServiceFactory.cs" />
-    <Compile Include="Workspace\Host\TemporaryStorage\TemporaryStorageServiceFactory.MemoryMappedFiles.cs" />
+    <Compile Include="Workspace\Host\TemporaryStorage\TemporaryStorageServiceFactory.MemoryMappedInfo.cs" />
     <Compile Include="Workspace\Host\TextFactory\DesktopTextFactoryService.cs" />
     <Compile Include="Workspace\MSBuild\CSharp\CSharpProjectFileLoader.cs" />
     <Compile Include="Workspace\MSBuild\CSharp\CSharpProjectFileLoader.CSharpProjectFile.cs" />

From d80ef0cc640a11a6660667780abb6d49ffc29803 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 15:09:06 -0700
Subject: [PATCH 236/284] Move DocumentHighlights data types down to the
 'Features' layer.

---
 .../CSharp/CSharpEditorFeatures.csproj        |  2 -
 .../CSharpDocumentHighlightsService.cs        | 13 ---
 src/EditorFeatures/Core/EditorFeatures.csproj | 19 ++--
 ...viewReferenceHighlightingTaggerProvider.cs |  2 +-
 ...HighlightingAdditionalReferenceProvider.cs | 14 ---
 ...htReferenceCommandHandler.StartComparer.cs |  2 +-
 ...ivateToHighlightReferenceCommandHandler.cs |  2 +-
 ...ReferenceHighlightingViewTaggerProvider.cs |  3 +-
 .../Tags}/DefinitionHighlightTag.cs           |  2 +-
 .../Tags}/DefinitionHighlightTagDefinition.cs |  2 +-
 .../Tags}/ReferenceHighlightTag.cs            |  2 +-
 .../Tags}/WrittenReferenceHighlightTag.cs     |  2 +-
 .../WrittenReferenceHighlightTagDefinition.cs |  2 +-
 .../AbstractReferenceHighlightingTests.vb     | 11 ++-
 .../VisualBasic/BasicEditorFeatures.vbproj    |  2 -
 ...HighlightingAdditionalReferenceProvider.vb | 18 ----
 .../CSharp/Portable/CSharpFeatures.csproj     |  1 +
 .../CSharpDocumentHighlightsService.cs}       | 26 ++---
 .../AbstractDocumentHighlightsService.cs      | 61 ++++++++----
 ...bstractDocumentHighlightsService_Remote.cs | 30 ++++++
 .../DocumentHighlightingOptions.cs            | 15 +++
 .../IDocumentHighlightsService.cs             |  3 +-
 .../IRemoteDocumentHighlights.cs              | 94 +++++++++++++++++++
 src/Features/Core/Portable/Features.csproj    |  5 +
 .../VisualBasic/Portable/BasicFeatures.vbproj |  1 +
 .../VisualBasicDocumentHighlightsService.vb   |  6 +-
 ...bstractTableDataSourceFindUsagesContext.cs |  2 +-
 .../WithReferencesFindUsagesContext.cs        |  2 +-
 .../WithoutReferencesFindUsagesContext.cs     |  2 +-
 .../Entries/DocumentSpanEntry.cs              |  4 +-
 .../CSharp/CSharpReferenceHighlighting.cs     |  3 +-
 .../VisualBasic/BasicReferenceHighlighting.cs |  3 +-
 .../TestUtilities/WellKnownTagNames.cs        |  2 +-
 .../Remote/ServiceHub/ServiceHub.csproj       |  1 +
 .../CodeAnalysisService_DocumentHighlights.cs | 28 ++++++
 35 files changed, 270 insertions(+), 117 deletions(-)
 delete mode 100644 src/EditorFeatures/CSharp/HighlightReferences/CSharpDocumentHighlightsService.cs
 delete mode 100644 src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IReferenceHighlightingAdditionalReferenceProvider.cs
 rename src/EditorFeatures/Core/{Implementation => }/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs (87%)
 rename src/EditorFeatures/Core/{Implementation => }/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs (98%)
 rename src/EditorFeatures/Core/{Implementation => }/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs (98%)
 rename src/EditorFeatures/Core/{Implementation/ReferenceHighlighting => ReferenceHighlighting/Tags}/DefinitionHighlightTag.cs (88%)
 rename src/EditorFeatures/Core/{Implementation/ReferenceHighlighting => ReferenceHighlighting/Tags}/DefinitionHighlightTagDefinition.cs (92%)
 rename src/EditorFeatures/Core/{Implementation/ReferenceHighlighting => ReferenceHighlighting/Tags}/ReferenceHighlightTag.cs (87%)
 rename src/EditorFeatures/Core/{Implementation/ReferenceHighlighting => ReferenceHighlighting/Tags}/WrittenReferenceHighlightTag.cs (88%)
 rename src/EditorFeatures/Core/{Implementation/ReferenceHighlighting => ReferenceHighlighting/Tags}/WrittenReferenceHighlightTagDefinition.cs (91%)
 delete mode 100644 src/EditorFeatures/VisualBasic/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.vb
 rename src/{EditorFeatures/CSharp/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.cs => Features/CSharp/Portable/DocumentHighlighting/CSharpDocumentHighlightsService.cs} (70%)
 rename src/{EditorFeatures/Core/Implementation/ReferenceHighlighting => Features/Core/Portable/DocumentHighlighting}/AbstractDocumentHighlightsService.cs (82%)
 create mode 100644 src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService_Remote.cs
 create mode 100644 src/Features/Core/Portable/DocumentHighlighting/DocumentHighlightingOptions.cs
 rename src/{EditorFeatures/Core/Implementation/ReferenceHighlighting => Features/Core/Portable/DocumentHighlighting}/IDocumentHighlightsService.cs (95%)
 create mode 100644 src/Features/Core/Portable/DocumentHighlighting/IRemoteDocumentHighlights.cs
 rename src/{EditorFeatures/VisualBasic/HighlightReferences => Features/VisualBasic/Portable/DocumentHighlighting}/VisualBasicDocumentHighlightsService.vb (73%)
 create mode 100644 src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_DocumentHighlights.cs

diff --git a/src/EditorFeatures/CSharp/CSharpEditorFeatures.csproj b/src/EditorFeatures/CSharp/CSharpEditorFeatures.csproj
index 508f732f4d6cb..4369095c0de14 100644
--- a/src/EditorFeatures/CSharp/CSharpEditorFeatures.csproj
+++ b/src/EditorFeatures/CSharp/CSharpEditorFeatures.csproj
@@ -136,14 +136,12 @@
     <Compile Include="Highlighting\KeywordHighlighters\UnsafeStatementHighlighter.cs" />
     <Compile Include="Highlighting\KeywordHighlighters\UsingStatementHighlighter.cs" />
     <Compile Include="Highlighting\KeywordHighlighters\YieldStatementHighlighter.cs" />
-    <Compile Include="HighlightReferences\CSharpDocumentHighlightsService.cs" />
     <Compile Include="InlineRename\CSharpEditorInlineRenameService.cs" />
     <Compile Include="LanguageServices\CSharpContentTypeLanguageService.cs" />
     <Compile Include="LineSeparators\CSharpLineSeparatorService.cs" />
     <Compile Include="NavigationBar\CSharpNavigationBarItemService.cs" />
     <Compile Include="QuickInfo\SemanticQuickInfoProvider.cs" />
     <Compile Include="QuickInfo\SyntacticQuickInfoProvider.cs" />
-    <Compile Include="ReferenceHighlighting\ReferenceHighlightingAdditionalReferenceProvider.cs" />
     <Compile Include="RenameTracking\CSharpRenameTrackingCodeFixProvider.cs" />
     <Compile Include="RenameTracking\CSharpRenameTrackingLanguageHeuristicsService.cs" />
     <Compile Include="SplitStringLiteral\SplitStringLiteralCommandHandler.cs" />
diff --git a/src/EditorFeatures/CSharp/HighlightReferences/CSharpDocumentHighlightsService.cs b/src/EditorFeatures/CSharp/HighlightReferences/CSharpDocumentHighlightsService.cs
deleted file mode 100644
index c1f3baf669ed0..0000000000000
--- a/src/EditorFeatures/CSharp/HighlightReferences/CSharpDocumentHighlightsService.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Composition;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
-using Microsoft.CodeAnalysis.Host.Mef;
-
-namespace Microsoft.CodeAnalysis.Editor.CSharp.HighlightReferences
-{
-    [ExportLanguageService(typeof(IDocumentHighlightsService), LanguageNames.CSharp), Shared]
-    internal class CSharpDocumentHighlightsService : AbstractDocumentHighlightsService
-    {
-    }
-}
diff --git a/src/EditorFeatures/Core/EditorFeatures.csproj b/src/EditorFeatures/Core/EditorFeatures.csproj
index c4ca714ba6082..b0f5de3f27b5d 100644
--- a/src/EditorFeatures/Core/EditorFeatures.csproj
+++ b/src/EditorFeatures/Core/EditorFeatures.csproj
@@ -168,6 +168,14 @@
     <Compile Include="Implementation\Structure\BlockTagState.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionSetComparer.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionsSource.cs" />
+    <Compile Include="ReferenceHighlighting\NagivateToHighlightReferenceCommandHandler.cs" />
+    <Compile Include="ReferenceHighlighting\NagivateToHighlightReferenceCommandHandler.StartComparer.cs" />
+    <Compile Include="ReferenceHighlighting\ReferenceHighlightingViewTaggerProvider.cs" />
+    <Compile Include="ReferenceHighlighting\Tags\DefinitionHighlightTag.cs" />
+    <Compile Include="ReferenceHighlighting\Tags\DefinitionHighlightTagDefinition.cs" />
+    <Compile Include="ReferenceHighlighting\Tags\ReferenceHighlightTag.cs" />
+    <Compile Include="ReferenceHighlighting\Tags\WrittenReferenceHighlightTag.cs" />
+    <Compile Include="ReferenceHighlighting\Tags\WrittenReferenceHighlightTagDefinition.cs" />
     <Compile Include="Implementation\InfoBar\EditorInfoBarService.cs" />
     <Compile Include="SymbolSearch\IAddReferenceDatabaseWrapper.cs" />
     <Compile Include="SymbolSearch\IDatabaseFactoryService.cs" />
@@ -631,8 +639,6 @@
     <Compile Include="Implementation\Peek\PeekableItemSource.cs" />
     <Compile Include="Implementation\Peek\PeekableItemSourceProvider.cs" />
     <Compile Include="Implementation\Peek\PeekHelpers.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\WrittenReferenceHighlightTag.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\WrittenReferenceHighlightTagDefinition.cs" />
     <Compile Include="Implementation\RenameTracking\IRenameTrackingLanguageHeuristicsService.cs" />
     <Compile Include="Implementation\RenameTracking\RenameTrackingCancellationCommandHandler.cs" />
     <Compile Include="Implementation\RenameTracking\RenameTrackingTagDefinition.cs" />
@@ -644,15 +650,6 @@
     <Compile Include="Implementation\Preview\PreviewConflictViewTaggerProvider.cs" />
     <Compile Include="Implementation\Preview\PreviewFactoryService.cs" />
     <Compile Include="Implementation\Preview\PreviewWarningViewTaggerProvider.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\AbstractDocumentHighlightsService.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\DefinitionHighlightTag.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\DefinitionHighlightTagDefinition.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\IDocumentHighlightsService.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\IReferenceHighlightingAdditionalReferenceProvider.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\NagivateToHighlightReferenceCommandHandler.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\NagivateToHighlightReferenceCommandHandler.StartComparer.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\ReferenceHighlightingViewTaggerProvider.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\ReferenceHighlightTag.cs" />
     <Compile Include="Implementation\RenameTracking\AbstractRenameTrackingCodeFixProvider.cs" />
     <Compile Include="Implementation\RenameTracking\RenameTrackingDiagnosticAnalyzer.cs" />
     <Compile Include="Implementation\RenameTracking\RenameTrackingTaggerProvider.cs" />
diff --git a/src/EditorFeatures/Core/Implementation/Preview/PreviewReferenceHighlightingTaggerProvider.cs b/src/EditorFeatures/Core/Implementation/Preview/PreviewReferenceHighlightingTaggerProvider.cs
index 29a2060e254e3..5c90ff6b8f179 100644
--- a/src/EditorFeatures/Core/Implementation/Preview/PreviewReferenceHighlightingTaggerProvider.cs
+++ b/src/EditorFeatures/Core/Implementation/Preview/PreviewReferenceHighlightingTaggerProvider.cs
@@ -6,7 +6,7 @@
 using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Text.Tagging;
 using Microsoft.VisualStudio.Utilities;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.Preview
 {
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IReferenceHighlightingAdditionalReferenceProvider.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IReferenceHighlightingAdditionalReferenceProvider.cs
deleted file mode 100644
index 694a5b6e505a2..0000000000000
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IReferenceHighlightingAdditionalReferenceProvider.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Host;
-
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
-{
-    internal interface IReferenceHighlightingAdditionalReferenceProvider : ILanguageService
-    {
-        Task<IEnumerable<Location>> GetAdditionalReferencesAsync(Document document, ISymbol symbol, CancellationToken cancellationToken);
-    }
-}
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs b/src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
similarity index 87%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
index 76b72d5268f3b..125416fd75162 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.StartComparer.cs
@@ -3,7 +3,7 @@
 using System.Collections.Generic;
 using Microsoft.VisualStudio.Text;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     internal partial class NavigateToHighlightReferenceCommandHandler
     {
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs b/src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
similarity index 98%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
index a0997e4009c8a..07a6b67793a85 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/NagivateToHighlightReferenceCommandHandler.cs
@@ -14,7 +14,7 @@
 using Microsoft.VisualStudio.Text.Tagging;
 using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     [ExportCommandHandler(PredefinedCommandHandlerNames.NavigateToHighlightedReference,
        ContentTypeNames.RoslynContentType)]
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs b/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
similarity index 98%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
index cbad756b7bd6a..e2367ad5f5d3d 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
@@ -6,6 +6,7 @@
 using System.ComponentModel.Composition;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 using Microsoft.CodeAnalysis.Editor.Tagging;
@@ -21,7 +22,7 @@
 using Microsoft.VisualStudio.Utilities;
 using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     [Export(typeof(IViewTaggerProvider))]
     [ContentType(ContentTypeNames.RoslynContentType)]
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTag.cs b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTag.cs
similarity index 88%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTag.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTag.cs
index 2f5873a759429..0b974c620bfa2 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTag.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTag.cs
@@ -2,7 +2,7 @@
 
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     internal class DefinitionHighlightTag : NavigableHighlightTag
     {
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTagDefinition.cs b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTagDefinition.cs
similarity index 92%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTagDefinition.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTagDefinition.cs
index b5a8023f8297e..5580291757cf8 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/DefinitionHighlightTagDefinition.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/DefinitionHighlightTagDefinition.cs
@@ -5,7 +5,7 @@
 using Microsoft.VisualStudio.Text.Classification;
 using Microsoft.VisualStudio.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     [Export(typeof(EditorFormatDefinition))]
     [Name(DefinitionHighlightTag.TagId)]
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightTag.cs b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/ReferenceHighlightTag.cs
similarity index 87%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightTag.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/Tags/ReferenceHighlightTag.cs
index 6c7d2cddc337b..299c701a98780 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/ReferenceHighlightTag.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/ReferenceHighlightTag.cs
@@ -2,7 +2,7 @@
 
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     internal class ReferenceHighlightTag : NavigableHighlightTag
     {
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTag.cs b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTag.cs
similarity index 88%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTag.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTag.cs
index b4d35d64ae6b1..d6f8df3342be5 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTag.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTag.cs
@@ -2,7 +2,7 @@
 
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     internal class WrittenReferenceHighlightTag : NavigableHighlightTag
     {
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTagDefinition.cs b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTagDefinition.cs
similarity index 91%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTagDefinition.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTagDefinition.cs
index 8db19cc5cb2b4..74323824a5056 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/WrittenReferenceHighlightTagDefinition.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/Tags/WrittenReferenceHighlightTagDefinition.cs
@@ -5,7 +5,7 @@
 using Microsoft.VisualStudio.Text.Classification;
 using Microsoft.VisualStudio.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 {
     [Export(typeof(EditorFormatDefinition))]
     [Name(WrittenReferenceHighlightTag.TagId)]
diff --git a/src/EditorFeatures/Test2/ReferenceHighlighting/AbstractReferenceHighlightingTests.vb b/src/EditorFeatures/Test2/ReferenceHighlighting/AbstractReferenceHighlightingTests.vb
index ab5ab6a8ab80b..7c9591274611f 100644
--- a/src/EditorFeatures/Test2/ReferenceHighlighting/AbstractReferenceHighlightingTests.vb
+++ b/src/EditorFeatures/Test2/ReferenceHighlighting/AbstractReferenceHighlightingTests.vb
@@ -1,7 +1,8 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports System.Threading
-Imports Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+Imports Microsoft.CodeAnalysis.DocumentHighlighting
+Imports Microsoft.CodeAnalysis.Editor.ReferenceHighlighting
 Imports Microsoft.CodeAnalysis.Editor.Shared.Extensions
 Imports Microsoft.CodeAnalysis.Editor.Shared.Options
 Imports Microsoft.CodeAnalysis.Editor.Shared.Tagging
@@ -16,9 +17,17 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.ReferenceHighlighting
 
     Public MustInherit Class AbstractReferenceHighlightingTests
         Protected Async Function VerifyHighlightsAsync(test As XElement, Optional optionIsEnabled As Boolean = True) As Tasks.Task
+            Await VerifyHighlightsAsync(test, optionIsEnabled, outOfProcess:=False)
+            Await VerifyHighlightsAsync(test, optionIsEnabled, outOfProcess:=True)
+        End Function
+
+        Private Async Function VerifyHighlightsAsync(test As XElement, optionIsEnabled As Boolean, outOfProcess As Boolean) As Tasks.Task
             Using workspace = TestWorkspace.Create(test)
                 WpfTestCase.RequireWpfFact($"{NameOf(AbstractReferenceHighlightingTests)}.VerifyHighlightsAsync creates asynchronous taggers")
 
+                workspace.Options = workspace.Options.WithChangedOption(
+                    DocumentHighlightingOptions.OutOfProcessAllowed, outOfProcess)
+
                 Dim tagProducer = New ReferenceHighlightingViewTaggerProvider(
                     workspace.GetService(Of IForegroundNotificationService),
                     workspace.GetService(Of ISemanticChangeNotificationService),
diff --git a/src/EditorFeatures/VisualBasic/BasicEditorFeatures.vbproj b/src/EditorFeatures/VisualBasic/BasicEditorFeatures.vbproj
index 531d79a604a6f..79ee5ff8d6c4c 100644
--- a/src/EditorFeatures/VisualBasic/BasicEditorFeatures.vbproj
+++ b/src/EditorFeatures/VisualBasic/BasicEditorFeatures.vbproj
@@ -129,7 +129,6 @@
     <Compile Include="Highlighting\KeywordHighlighters\XmlEmbeddedExpressionHighlighter.vb" />
     <Compile Include="Highlighting\KeywordHighlighters\XmlProcessingInstructionHighlighter.vb" />
     <Compile Include="Highlighting\KeywordHighlightingHelpers.vb" />
-    <Compile Include="HighlightReferences\VisualBasicDocumentHighlightsService.vb" />
     <Compile Include="ImplementAbstractClass\ImplementAbstractClassCommandHandler.vb" />
     <Compile Include="ImplementInterface\ImplementInterfaceCommandHandler.vb" />
     <Compile Include="InlineRename\VisualBasicEditorInlineRenameService.vb" />
@@ -155,7 +154,6 @@
     <Compile Include="NavigationBar\GenerateMethodItem.vb" />
     <Compile Include="NavigationBar\VisualBasicNavigationBarItemService.vb" />
     <Compile Include="QuickInfo\SemanticQuickInfoProvider.vb" />
-    <Compile Include="ReferenceHighlighting\ReferenceHighlightingAdditionalReferenceProvider.vb" />
     <Compile Include="RenameTracking\BasicRenameTrackingLanguageHeuristicsService.vb" />
     <Compile Include="RenameTracking\RenameTrackingCodeFixProvider.vb" />
     <Compile Include="TextStructureNavigation\TextStructureNavigatorProvider.vb" />
diff --git a/src/EditorFeatures/VisualBasic/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.vb b/src/EditorFeatures/VisualBasic/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.vb
deleted file mode 100644
index 2c95b09d3a2fb..0000000000000
--- a/src/EditorFeatures/VisualBasic/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.vb
+++ /dev/null
@@ -1,18 +0,0 @@
-' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-Imports System.Composition
-Imports System.Threading
-Imports System.Threading.Tasks
-Imports Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
-Imports Microsoft.CodeAnalysis.Host.Mef
-
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.ReferenceHighlighting
-    <ExportLanguageService(GetType(IReferenceHighlightingAdditionalReferenceProvider), LanguageNames.VisualBasic), [Shared]>
-    Friend Class ReferenceHighlightingAdditionalReferenceProvider
-        Implements IReferenceHighlightingAdditionalReferenceProvider
-
-        Public Function GetAdditionalReferencesAsync(document As Document, symbol As ISymbol, cancellationToken As CancellationToken) As Task(Of IEnumerable(Of Location)) Implements IReferenceHighlightingAdditionalReferenceProvider.GetAdditionalReferencesAsync
-            Return SpecializedTasks.EmptyEnumerable(Of Location)()
-        End Function
-    End Class
-End Namespace
diff --git a/src/Features/CSharp/Portable/CSharpFeatures.csproj b/src/Features/CSharp/Portable/CSharpFeatures.csproj
index 5a98016cdb2c5..258abf0a7cc9f 100644
--- a/src/Features/CSharp/Portable/CSharpFeatures.csproj
+++ b/src/Features/CSharp/Portable/CSharpFeatures.csproj
@@ -81,6 +81,7 @@
     </Compile>
     <Compile Include="DesignerAttributes\CSharpDesignerAttributeService.cs" />
     <Compile Include="Completion\CompletionProviders\DeclarationNameCompletionProvider.cs" />
+    <Compile Include="DocumentHighlighting\CSharpDocumentHighlightsService.cs" />
     <Compile Include="ImplementAbstractClass\CSharpImplementAbstractClassCodeFixProvider.cs" />
     <Compile Include="ImplementInterface\CSharpImplementInterfaceCodeFixProvider.cs" />
     <Compile Include="InitializeParameter\CSharpAddParameterCheckCodeRefactoringProvider.cs" />
diff --git a/src/EditorFeatures/CSharp/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.cs b/src/Features/CSharp/Portable/DocumentHighlighting/CSharpDocumentHighlightsService.cs
similarity index 70%
rename from src/EditorFeatures/CSharp/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.cs
rename to src/Features/CSharp/Portable/DocumentHighlighting/CSharpDocumentHighlightsService.cs
index 2321c81cc552e..4788978fd5719 100644
--- a/src/EditorFeatures/CSharp/ReferenceHighlighting/ReferenceHighlightingAdditionalReferenceProvider.cs
+++ b/src/Features/CSharp/Portable/DocumentHighlighting/CSharpDocumentHighlightsService.cs
@@ -1,32 +1,31 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Composition;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.Host.Mef;
-using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.CSharp.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.CSharp.DocumentHighlighting
 {
-    [ExportLanguageService(typeof(IReferenceHighlightingAdditionalReferenceProvider), LanguageNames.CSharp), Shared]
-    internal class ReferenceHighlightingAdditionalReferenceProvider : IReferenceHighlightingAdditionalReferenceProvider
+    [ExportLanguageService(typeof(IDocumentHighlightsService), LanguageNames.CSharp), Shared]
+    internal class CSharpDocumentHighlightsService : AbstractDocumentHighlightsService
     {
-        public async Task<IEnumerable<Location>> GetAdditionalReferencesAsync(
+        protected override async Task<ImmutableArray<Location>> GetAdditionalReferencesAsync(
             Document document, ISymbol symbol, CancellationToken cancellationToken)
         {
             // The FindRefs engine won't find references through 'var' for performance reasons.
             // Also, they are not needed for things like rename/sig change, and the normal find refs
-            // feature.  However, we would lke the results to be highlighted to get a good experience
+            // feature.  However, we would like the results to be highlighted to get a good experience
             // while editing (especially since highlighting may have been invoked off of 'var' in
             // the first place).
             //
             // So we look for the references through 'var' directly in this file and add them to the
             // results found by the engine.
-            List<Location> results = null;
+            var results = ArrayBuilder<Location>.GetInstance();
 
             if (symbol is INamedTypeSymbol && symbol.Name != "var")
             {
@@ -52,18 +51,13 @@ public async Task<IEnumerable<Location>> GetAdditionalReferencesAsync(
 
                         if (originalSymbol.Equals(boundSymbol))
                         {
-                            if (results == null)
-                            {
-                                results = new List<Location>();
-                            }
-
                             results.Add(type.GetLocation());
                         }
                     }
                 }
             }
 
-            return results ?? SpecializedCollections.EmptyEnumerable<Location>();
+            return results.ToImmutableAndFree();
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/AbstractDocumentHighlightsService.cs b/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService.cs
similarity index 82%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/AbstractDocumentHighlightsService.cs
rename to src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService.cs
index 8a90b0062620f..91b1933bd7692 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/AbstractDocumentHighlightsService.cs
+++ b/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService.cs
@@ -14,12 +14,47 @@
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+namespace Microsoft.CodeAnalysis.DocumentHighlighting
 {
-    internal abstract class AbstractDocumentHighlightsService : IDocumentHighlightsService
+    internal abstract partial class AbstractDocumentHighlightsService : IDocumentHighlightsService
     {
         public async Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsAsync(
             Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken)
+        {
+            var (succeeded, highlights) = await GetDocumentHighlightsInRemoteProcessAsync(
+                document, position, documentsToSearch, cancellationToken).ConfigureAwait(false);
+
+            if (succeeded)
+            {
+                return highlights;
+            }
+
+            return await GetDocumentHighlightsInCurrentProcessAsync(
+                document, position, documentsToSearch, cancellationToken).ConfigureAwait(false);
+        }
+
+        private async Task<(bool succeeded, ImmutableArray<DocumentHighlights> highlights)> GetDocumentHighlightsInRemoteProcessAsync(
+            Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken)
+        {
+            using (var session = await TryGetRemoteSessionAsync(
+                document.Project.Solution, cancellationToken).ConfigureAwait(false))
+            {
+                if (session == null)
+                {
+                    return (succeeded: false, ImmutableArray<DocumentHighlights>.Empty);
+                }
+
+                var result = await session.InvokeAsync<SerializableDocumentHighlights[]>(
+                    nameof(IRemoteDocumentHighlights.GetDocumentHighlightsAsync),
+                    document.Id,
+                    position,
+                    documentsToSearch.Select(d => d.Id).ToArray()).ConfigureAwait(false);
+                return (true, SerializableDocumentHighlights.Rehydrate(result, document.Project.Solution));
+            }
+        }
+
+        private async Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsInCurrentProcessAsync(
+            Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken)
         {
             // use speculative semantic model to see whether we are on a symbol we can do HR
             var span = new TextSpan(position, 0);
@@ -41,11 +76,11 @@ public async Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsAsync
 
             // Get unique tags for referenced symbols
             return await GetTagsForReferencedSymbolAsync(
-                new SymbolAndProjectId(symbol, document.Project.Id), documentsToSearch, 
+                new SymbolAndProjectId(symbol, document.Project.Id), documentsToSearch,
                 solution, cancellationToken).ConfigureAwait(false);
         }
 
-        private async Task<ISymbol> GetSymbolToSearchAsync(Document document, int position, SemanticModel semanticModel, ISymbol symbol, CancellationToken cancellationToken)
+        private static async Task<ISymbol> GetSymbolToSearchAsync(Document document, int position, SemanticModel semanticModel, ISymbol symbol, CancellationToken cancellationToken)
         {
             // see whether we can use the symbol as it is
             var currentSemanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
@@ -82,7 +117,7 @@ await SymbolFinder.FindReferencesAsync(
             return ImmutableArray<DocumentHighlights>.Empty;
         }
 
-        private bool ShouldConsiderSymbol(ISymbol symbol)
+        private static bool ShouldConsiderSymbol(ISymbol symbol)
         {
             switch (symbol.Kind)
             {
@@ -132,19 +167,13 @@ private async Task<ImmutableArray<DocumentHighlights>> FilterAndCreateSpansAsync
                 documentsToSearch, cancellationToken).ConfigureAwait(false);
         }
 
-        private Task<IEnumerable<Location>> GetAdditionalReferencesAsync(
+        protected virtual Task<ImmutableArray<Location>> GetAdditionalReferencesAsync(
             Document document, ISymbol symbol, CancellationToken cancellationToken)
         {
-            var additionalReferenceProvider = document.Project.LanguageServices.GetService<IReferenceHighlightingAdditionalReferenceProvider>();
-            if (additionalReferenceProvider != null)
-            {
-                return additionalReferenceProvider.GetAdditionalReferencesAsync(document, symbol, cancellationToken);
-            }
-
-            return Task.FromResult(SpecializedCollections.EmptyEnumerable<Location>());
+            return SpecializedTasks.EmptyImmutableArray<Location>();
         }
 
-        private async Task<ImmutableArray<DocumentHighlights>> CreateSpansAsync(
+        private static async Task<ImmutableArray<DocumentHighlights>> CreateSpansAsync(
             Solution solution,
             ISymbol symbol,
             IEnumerable<ReferencedSymbol> references,
@@ -252,7 +281,7 @@ private static bool ShouldIncludeDefinition(ISymbol symbol)
             return true;
         }
 
-        private async Task AddLocationSpan(Location location, Solution solution, HashSet<DocumentSpan> spanSet, MultiDictionary<Document, HighlightSpan> tagList, HighlightSpanKind kind, CancellationToken cancellationToken)
+        private static async Task AddLocationSpan(Location location, Solution solution, HashSet<DocumentSpan> spanSet, MultiDictionary<Document, HighlightSpan> tagList, HighlightSpanKind kind, CancellationToken cancellationToken)
         {
             var span = await GetLocationSpanAsync(solution, location, cancellationToken).ConfigureAwait(false);
             if (span != null && !spanSet.Contains(span.Value))
@@ -262,7 +291,7 @@ private async Task AddLocationSpan(Location location, Solution solution, HashSet
             }
         }
 
-        private async Task<DocumentSpan?> GetLocationSpanAsync(
+        private static async Task<DocumentSpan?> GetLocationSpanAsync(
             Solution solution, Location location, CancellationToken cancellationToken)
         {
             try
diff --git a/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService_Remote.cs b/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService_Remote.cs
new file mode 100644
index 0000000000000..7efad4a9663df
--- /dev/null
+++ b/src/Features/Core/Portable/DocumentHighlighting/AbstractDocumentHighlightsService_Remote.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Remote;
+
+namespace Microsoft.CodeAnalysis.DocumentHighlighting
+{
+    internal abstract partial class AbstractDocumentHighlightsService : IDocumentHighlightsService
+    {
+        private static async Task<RemoteHostClient.Session> TryGetRemoteSessionAsync(
+            Solution solution, CancellationToken cancellationToken)
+        {
+            var outOfProcessAllowed = solution.Workspace.Options.GetOption(DocumentHighlightingOptions.OutOfProcessAllowed);
+            if (!outOfProcessAllowed)
+            {
+                return null;
+            }
+
+            var client = await solution.Workspace.TryGetRemoteHostClientAsync(cancellationToken).ConfigureAwait(false);
+            if (client == null)
+            {
+                return null;
+            }
+
+            return await client.TryCreateCodeAnalysisServiceSessionAsync(
+                solution, cancellationToken).ConfigureAwait(false);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Features/Core/Portable/DocumentHighlighting/DocumentHighlightingOptions.cs b/src/Features/Core/Portable/DocumentHighlighting/DocumentHighlightingOptions.cs
new file mode 100644
index 0000000000000..0363999301f11
--- /dev/null
+++ b/src/Features/Core/Portable/DocumentHighlighting/DocumentHighlightingOptions.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis.Options;
+
+namespace Microsoft.CodeAnalysis.DocumentHighlighting
+{
+    internal static class DocumentHighlightingOptions
+    {
+        private const string LocalRegistryPath = @"Roslyn\Features\DocumentHighlighting\";
+
+        public static readonly Option<bool> OutOfProcessAllowed = new Option<bool>(
+            nameof(DocumentHighlightingOptions), nameof(OutOfProcessAllowed), defaultValue: false,
+            storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(OutOfProcessAllowed)));
+    }
+}
\ No newline at end of file
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs b/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
similarity index 95%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs
rename to src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
index f86be931963c1..0e08d4418c4f5 100644
--- a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs
+++ b/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
@@ -1,13 +1,12 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.Editor
+namespace Microsoft.CodeAnalysis.DocumentHighlighting
 {
     internal enum HighlightSpanKind
     {
diff --git a/src/Features/Core/Portable/DocumentHighlighting/IRemoteDocumentHighlights.cs b/src/Features/Core/Portable/DocumentHighlighting/IRemoteDocumentHighlights.cs
new file mode 100644
index 0000000000000..b58c6f35a18fd
--- /dev/null
+++ b/src/Features/Core/Portable/DocumentHighlighting/IRemoteDocumentHighlights.cs
@@ -0,0 +1,94 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.DocumentHighlighting
+{
+    internal interface IRemoteDocumentHighlights
+    {
+        Task<SerializableDocumentHighlights[]> GetDocumentHighlightsAsync(
+            DocumentId documentId, int position, DocumentId[] documentIdsToSearch);
+    }
+
+    internal struct SerializableDocumentHighlights
+    {
+        public DocumentId DocumentId;
+        public SerializableHighlightSpan[] HighlightSpans;
+
+        public static ImmutableArray<DocumentHighlights> Rehydrate(SerializableDocumentHighlights[] array, Solution solution)
+        {
+            var result = ArrayBuilder<DocumentHighlights>.GetInstance(array.Length);
+            foreach (var dehydrated in array)
+            {
+                result.Push(dehydrated.Rehydrate(solution));
+            }
+
+            return result.ToImmutableAndFree();
+        }
+
+        private DocumentHighlights Rehydrate(Solution solution)
+            => new DocumentHighlights(solution.GetDocument(DocumentId), SerializableHighlightSpan.Rehydrate(HighlightSpans));
+
+        public static SerializableDocumentHighlights[] Dehydrate(ImmutableArray<DocumentHighlights> array)
+        {
+            var result = new SerializableDocumentHighlights[array.Length];
+            var index = 0;
+            foreach (var highlights in array)
+            {
+                result[index] = Dehydrate(highlights);
+                index++;
+            }
+
+            return result;
+        }
+
+        private static SerializableDocumentHighlights Dehydrate(DocumentHighlights highlights)
+            => new SerializableDocumentHighlights
+            {
+                DocumentId = highlights.Document.Id,
+                HighlightSpans = SerializableHighlightSpan.Dehydrate(highlights.HighlightSpans)
+            };
+    }
+
+    internal struct SerializableHighlightSpan
+    {
+        public TextSpan TextSpan;
+        public HighlightSpanKind Kind;
+
+        internal static SerializableHighlightSpan[] Dehydrate(ImmutableArray<HighlightSpan> array)
+        {
+            var result = new SerializableHighlightSpan[array.Length];
+            var index = 0;
+            foreach (var span in array)
+            {
+                result[index] = Dehydrate(span);
+                index++;
+            }
+
+            return result;
+        }
+
+        private static SerializableHighlightSpan Dehydrate(HighlightSpan span)
+            => new SerializableHighlightSpan
+            {
+                Kind = span.Kind,
+                TextSpan = span.TextSpan
+            };
+
+        internal static ImmutableArray<HighlightSpan> Rehydrate(SerializableHighlightSpan[] array)
+        {
+            var result = ArrayBuilder<HighlightSpan>.GetInstance(array.Length);
+            foreach (var dehydrated in array)
+            {
+                result.Push(dehydrated.Rehydrate());
+            }
+
+            return result.ToImmutableAndFree();
+        }
+
+        private HighlightSpan Rehydrate()
+            => new HighlightSpan(TextSpan, Kind);
+    }
+}
\ No newline at end of file
diff --git a/src/Features/Core/Portable/Features.csproj b/src/Features/Core/Portable/Features.csproj
index cff5327a8c52d..25a06421f4352 100644
--- a/src/Features/Core/Portable/Features.csproj
+++ b/src/Features/Core/Portable/Features.csproj
@@ -132,6 +132,7 @@
     <Compile Include="Diagnostics\DiagnosticArguments.cs" />
     <Compile Include="Diagnostics\DiagnosticResultSerializer.cs" />
     <Compile Include="Diagnostics\SymbolAnalysisContextExtensions.cs" />
+    <Compile Include="DocumentHighlighting\DocumentHighlightingOptions.cs" />
     <Compile Include="EncapsulateField\EncapsulateFieldRefactoringProvider.cs" />
     <Compile Include="ExtractInterface\ExtractInterfaceCodeRefactoringProvider.cs" />
     <Compile Include="CodeFixes\FixAllOccurrences\FixSomeCodeAction.cs" />
@@ -157,6 +158,10 @@
     <Compile Include="GenerateFromMembers\SelectedMemberInfo.cs" />
     <Compile Include="ImplementType\ImplementTypeOptions.cs" />
     <Compile Include="ImplementType\ImplementTypeOptionsProvider.cs" />
+    <Compile Include="DocumentHighlighting\AbstractDocumentHighlightsService.cs" />
+    <Compile Include="DocumentHighlighting\AbstractDocumentHighlightsService_Remote.cs" />
+    <Compile Include="DocumentHighlighting\IDocumentHighlightsService.cs" />
+    <Compile Include="DocumentHighlighting\IRemoteDocumentHighlights.cs" />
     <Compile Include="RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsCodeFixProvider.cs" />
     <Compile Include="RemoveUnnecessaryImports\IUnnecessaryImportsService.cs" />
     <Compile Include="NavigateTo\AbstractNavigateToSearchService.SearchResult.cs" />
diff --git a/src/Features/VisualBasic/Portable/BasicFeatures.vbproj b/src/Features/VisualBasic/Portable/BasicFeatures.vbproj
index f8df520cf1959..ac0829cdeb9c3 100644
--- a/src/Features/VisualBasic/Portable/BasicFeatures.vbproj
+++ b/src/Features/VisualBasic/Portable/BasicFeatures.vbproj
@@ -66,6 +66,7 @@
       <Link>InternalUtilities\LambdaUtilities.vb</Link>
     </Compile>
     <Compile Include="AddPackage\VisualBasicAddSpecificPackageCodeFixProvider.vb" />
+    <Compile Include="DocumentHighlighting\VisualBasicDocumentHighlightsService.vb" />
     <Compile Include="InitializeParameter\InitializeParameterHelpers.vb" />
     <Compile Include="InitializeParameter\VisualBasicAddParameterCheckCodeRefactoringProvider.vb" />
     <Compile Include="ChangeSignature\ChangeSignatureFormattingRule.vb" />
diff --git a/src/EditorFeatures/VisualBasic/HighlightReferences/VisualBasicDocumentHighlightsService.vb b/src/Features/VisualBasic/Portable/DocumentHighlighting/VisualBasicDocumentHighlightsService.vb
similarity index 73%
rename from src/EditorFeatures/VisualBasic/HighlightReferences/VisualBasicDocumentHighlightsService.vb
rename to src/Features/VisualBasic/Portable/DocumentHighlighting/VisualBasicDocumentHighlightsService.vb
index b0693439b5de7..2f925d3749ed3 100644
--- a/src/EditorFeatures/VisualBasic/HighlightReferences/VisualBasicDocumentHighlightsService.vb
+++ b/src/Features/VisualBasic/Portable/DocumentHighlighting/VisualBasicDocumentHighlightsService.vb
@@ -1,13 +1,13 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports System.Composition
-Imports Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting
+Imports Microsoft.CodeAnalysis.DocumentHighlighting
 Imports Microsoft.CodeAnalysis.Host.Mef
 
-Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.HighlightReferences
+Namespace Microsoft.CodeAnalysis.VisualBasic.DocumentHighlighting
     <ExportLanguageService(GetType(IDocumentHighlightsService), LanguageNames.VisualBasic), [Shared]>
     Friend Class VisualBasicDocumentHighlightsService
         Inherits AbstractDocumentHighlightsService
 
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/VisualStudio/Core/Next/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs b/src/VisualStudio/Core/Next/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
index e593f2f5ab596..c8cf14161ae4b 100644
--- a/src/VisualStudio/Core/Next/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
+++ b/src/VisualStudio/Core/Next/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
@@ -7,7 +7,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.Editor.FindUsages;
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.CodeAnalysis.Text;
diff --git a/src/VisualStudio/Core/Next/FindReferences/Contexts/WithReferencesFindUsagesContext.cs b/src/VisualStudio/Core/Next/FindReferences/Contexts/WithReferencesFindUsagesContext.cs
index 9973893c2464d..765612f4c86b2 100644
--- a/src/VisualStudio/Core/Next/FindReferences/Contexts/WithReferencesFindUsagesContext.cs
+++ b/src/VisualStudio/Core/Next/FindReferences/Contexts/WithReferencesFindUsagesContext.cs
@@ -8,7 +8,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Completion;
-using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.VisualStudio.Shell.FindAllReferences;
 using Roslyn.Utilities;
diff --git a/src/VisualStudio/Core/Next/FindReferences/Contexts/WithoutReferencesFindUsagesContext.cs b/src/VisualStudio/Core/Next/FindReferences/Contexts/WithoutReferencesFindUsagesContext.cs
index 5a5f6a2b02bf8..2456a495cfef6 100644
--- a/src/VisualStudio/Core/Next/FindReferences/Contexts/WithoutReferencesFindUsagesContext.cs
+++ b/src/VisualStudio/Core/Next/FindReferences/Contexts/WithoutReferencesFindUsagesContext.cs
@@ -3,7 +3,7 @@
 using System;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.VisualStudio.Shell.FindAllReferences;
 using Roslyn.Utilities;
diff --git a/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs b/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs
index 68c45919b30eb..f32bade84b9c2 100644
--- a/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs
+++ b/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs
@@ -7,10 +7,11 @@
 using System.Windows.Media;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.FindUsages;
 using Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Preview;
 using Microsoft.CodeAnalysis.FindUsages;
@@ -18,7 +19,6 @@
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Extensions;
 using Microsoft.VisualStudio.PlatformUI;
-using Microsoft.VisualStudio.Shell.TableControl;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
 
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpReferenceHighlighting.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpReferenceHighlighting.cs
index 627ac96efc079..8f527cbb55af5 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpReferenceHighlighting.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpReferenceHighlighting.cs
@@ -3,11 +3,10 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
-using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
 using Roslyn.Test.Utilities;
 using Xunit;
 
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicReferenceHighlighting.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicReferenceHighlighting.cs
index 873349a13f999..86a0a05fec482 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicReferenceHighlighting.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicReferenceHighlighting.cs
@@ -3,11 +3,10 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
-using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
 using Roslyn.Test.Utilities;
 using Xunit;
 
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/WellKnownTagNames.cs b/src/VisualStudio/IntegrationTest/TestUtilities/WellKnownTagNames.cs
index d765685a409f3..98dd6cba799a0 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/WellKnownTagNames.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/WellKnownTagNames.cs
@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
-using Microsoft.CodeAnalysis.Editor.Implementation.ReferenceHighlighting;
+using Microsoft.CodeAnalysis.Editor.ReferenceHighlighting;
 
 namespace Microsoft.VisualStudio.IntegrationTest.Utilities
 {
diff --git a/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj b/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj
index d6d11f07df18b..025bf020370a5 100644
--- a/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj
+++ b/src/Workspaces/Remote/ServiceHub/ServiceHub.csproj
@@ -73,6 +73,7 @@
     </Compile>
     <Compile Include="Services\CodeAnalysisService_CodeLens.cs" />
     <Compile Include="Services\CodeAnalysisService_DesignerAttributes.cs" />
+    <Compile Include="Services\CodeAnalysisService_DocumentHighlights.cs" />
     <Compile Include="Services\CodeAnalysisService_TodoComments.cs" />
     <Compile Include="Services\CodeAnalysisService_SymbolFinder.cs" />
     <Compile Include="Services\RemoteSymbolSearchUpdateEngine.cs" />
diff --git a/src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_DocumentHighlights.cs b/src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_DocumentHighlights.cs
new file mode 100644
index 0000000000000..b98c8e58a9146
--- /dev/null
+++ b/src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_DocumentHighlights.cs
@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.DocumentHighlighting;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+
+namespace Microsoft.CodeAnalysis.Remote
+{
+    // root level service for all Roslyn services
+    internal partial class CodeAnalysisService : IRemoteDocumentHighlights
+    {
+        public async Task<SerializableDocumentHighlights[]> GetDocumentHighlightsAsync(
+            DocumentId documentId, int position, DocumentId[] documentIdsToSearch)
+        {
+            var solution = await GetSolutionAsync().ConfigureAwait(false);
+            var document = solution.GetDocument(documentId);
+            var documentsToSearch = ImmutableHashSet.CreateRange(documentIdsToSearch.Select(solution.GetDocument));
+
+            var service = document.GetLanguageService<IDocumentHighlightsService>();
+            var result = await service.GetDocumentHighlightsAsync(
+                document, position, documentsToSearch, CancellationToken).ConfigureAwait(false);
+
+            return SerializableDocumentHighlights.Dehydrate(result);
+        }
+    }
+}
\ No newline at end of file

From 666c4eb7a7f7ae54a19f8d8b32fbf7547d893d42 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 15:34:02 -0700
Subject: [PATCH 237/284] Skip test.

---
 .../IntegrationTest/IntegrationTests/CSharp/CSharpNavigateTo.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpNavigateTo.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpNavigateTo.cs
index e76f870e7dba7..25c30d61a6551 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpNavigateTo.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpNavigateTo.cs
@@ -20,7 +20,7 @@ public CSharpNavigateTo(VisualStudioInstanceFactory instanceFactory)
         {
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.SignatureHelp)]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19530"), Trait(Traits.Feature, Traits.Features.SignatureHelp)]
         public void NavigateTo()
         {
             var project = new ProjectUtils.Project(ProjectName);

From 65b7418112f4e6ab526fa55002209093cedb0769 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 14:44:20 -0700
Subject: [PATCH 238/284] Ensure versions match.

---
 .../SymbolTree/SymbolTreeInfo_Metadata.cs     | 23 +++++++++++++------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
index 20cac6563cfcc..c4ac93508a6b9 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs
@@ -73,7 +73,7 @@ public static Task<SymbolTreeInfo> GetInfoForMetadataReferenceAsync(
         /// Produces a <see cref="SymbolTreeInfo"/> for a given <see cref="PortableExecutableReference"/>.
         /// Note:  will never return null;
         /// </summary>
-        public static Task<SymbolTreeInfo> GetInfoForMetadataReferenceAsync(
+        public static async Task<SymbolTreeInfo> GetInfoForMetadataReferenceAsync(
             Solution solution,
             PortableExecutableReference reference,
             Checksum checksum,
@@ -83,7 +83,7 @@ public static Task<SymbolTreeInfo> GetInfoForMetadataReferenceAsync(
             var metadataId = GetMetadataIdNoThrow(reference);
             if (metadataId == null)
             {
-                return Task.FromResult(CreateEmpty(checksum));
+                return CreateEmpty(checksum);
             }
 
             // Try to acquire the data outside the lock.  That way we can avoid any sort of 
@@ -92,17 +92,21 @@ public static Task<SymbolTreeInfo> GetInfoForMetadataReferenceAsync(
             // the lock is not being held most of the time).
             if (s_metadataIdToInfo.TryGetValue(metadataId, out var infoTask))
             {
-                return infoTask;
+                var info = await infoTask.ConfigureAwait(false);
+                if (info.Checksum == checksum)
+                {
+                    return info;
+                }
             }
 
             var metadata = GetMetadataNoThrow(reference);
             if (metadata == null)
             {
-                return Task.FromResult(CreateEmpty(checksum));
+                return CreateEmpty(checksum);
             }
 
-            return GetInfoForMetadataReferenceSlowAsync(
-                solution, reference, checksum, loadOnly, metadata, cancellationToken);
+            return await GetInfoForMetadataReferenceSlowAsync(
+                solution, reference, checksum, loadOnly, metadata, cancellationToken).ConfigureAwait(false);
         }
 
         private static async Task<SymbolTreeInfo> GetInfoForMetadataReferenceSlowAsync(
@@ -117,7 +121,11 @@ private static async Task<SymbolTreeInfo> GetInfoForMetadataReferenceSlowAsync(
                 cancellationToken.ThrowIfCancellationRequested();
                 if (s_metadataIdToInfo.TryGetValue(metadata.Id, out var infoTask))
                 {
-                    return await infoTask.ConfigureAwait(false);
+                    var oldInfo = await infoTask.ConfigureAwait(false);
+                    if (oldInfo.Checksum == checksum)
+                    {
+                        return oldInfo;
+                    }
                 }
 
                 var info = await TryLoadOrCreateMetadataSymbolTreeInfoAsync(
@@ -130,6 +138,7 @@ private static async Task<SymbolTreeInfo> GetInfoForMetadataReferenceSlowAsync(
                 // Cache the result in our dictionary.  Store it as a completed task so that 
                 // future callers don't need to allocate to get the result back.
                 infoTask = Task.FromResult(info);
+                s_metadataIdToInfo.Remove(metadata.Id);
                 s_metadataIdToInfo.Add(metadata.Id, infoTask);
 
                 return info;

From 3e570abdef3f07de51d0b589c64aa3c818fc2be0 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Mon, 15 May 2017 15:49:16 -0700
Subject: [PATCH 239/284] Use xunitassertVersion

---
 build/Targets/Packages.props              | 1 +
 src/Test/PdbUtilities/PdbUtilities.csproj | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/build/Targets/Packages.props b/build/Targets/Packages.props
index 3350acfec27bf..877de7a25362b 100644
--- a/build/Targets/Packages.props
+++ b/build/Targets/Packages.props
@@ -221,6 +221,7 @@
     <VSSDKComponentModelHostVersion>12.0.4</VSSDKComponentModelHostVersion>
     <VsWebsiteInteropVersion>8.0.0.0-alpha</VsWebsiteInteropVersion>
     <xunitVersion>2.2.0-beta4-build3444</xunitVersion>
+    <xunitassertVersion>2.2.0-beta4-build3444</xunitassertVersion>
     <xunitconsolenetcoreVersion>1.0.2-prerelease-00104</xunitconsolenetcoreVersion>
     <xunitrunnerconsoleVersion>2.2.0-beta4-build3444</xunitrunnerconsoleVersion>
     <xunitrunnervisualstudioVersion>2.2.0-beta4-build1194</xunitrunnervisualstudioVersion>
diff --git a/src/Test/PdbUtilities/PdbUtilities.csproj b/src/Test/PdbUtilities/PdbUtilities.csproj
index 25aa598910692..ba09f723d13e0 100644
--- a/src/Test/PdbUtilities/PdbUtilities.csproj
+++ b/src/Test/PdbUtilities/PdbUtilities.csproj
@@ -65,7 +65,7 @@
     <PackageReference Include="System.Reflection.Metadata" Version="$(SystemReflectionMetadataVersion)" />
     <PackageReference Include="System.Xml.ReaderWriter" Version="$(SystemXmlReaderWriterVersion)" />
     <PackageReference Include="System.ValueTuple" Version="$(SystemValueTupleVersion)" />
-    <PackageReference Include="xunit.assert" Version="$(xunitVersion)" />
+    <PackageReference Include="xunit.assert" Version="$(xunitassertVersion)" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\Compilers\Core\Portable\CodeAnalysis.csproj" />

From 0d8836aa66edd3eb4e18314a06cffa7b9ed51136 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Mon, 15 May 2017 15:50:05 -0700
Subject: [PATCH 240/284] Updated with final info bar text.

---
 .../AnalyzerVsixSuggestedActionCallback.cs    |  6 +--
 .../Core/Def/ServicesVSResources.Designer.cs  | 46 ++++++++-----------
 .../Core/Def/ServicesVSResources.resx         | 11 ++---
 3 files changed, 26 insertions(+), 37 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
index 8296361148e1b..c297f5fb45ef3 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -154,13 +154,13 @@ private void ShowInfoBarIfNecessary()
 
                     var infoBarService = _workspace.Services.GetRequiredService<IInfoBarService>();
                     infoBarService.ShowInfoBarInGlobalView(
-                        ServicesVSResources.Analyzer_vsix_try_description,
+                        ServicesVSResources.Try_the_preview_version_of_our_live_code_analysis_extension_which_provides_more_fixes_for_common_API_design_naming_performance_and_reliability_issues,
                         // Install link
-                        new InfoBarUI(title: ServicesVSResources.Analyzer_vsix_hyperlink,
+                        new InfoBarUI(title: ServicesVSResources.Learn_more,
                                       kind: InfoBarUI.UIKind.HyperLink,
                                       action: OpenInstallHyperlink),
                         // Don't show the InfoBar again link
-                        new InfoBarUI(title: ServicesVSResources.Analyzer_vsix_do_not_show_again,
+                        new InfoBarUI(title: ServicesVSResources.Never_show_this_again,
                                       kind: InfoBarUI.UIKind.Button,
                                       action: DoNotShowAgain));
                 }
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs b/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
index a6d1c5b6b7854..cf1f2a2526aa7 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.Designer.cs
@@ -226,33 +226,6 @@ internal static string Analyzer_reference_to_0_in_project_1 {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Do not show again.
-        /// </summary>
-        internal static string Analyzer_vsix_do_not_show_again {
-            get {
-                return ResourceManager.GetString("Analyzer_vsix_do_not_show_again", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Install.
-        /// </summary>
-        internal static string Analyzer_vsix_hyperlink {
-            get {
-                return ResourceManager.GetString("Analyzer_vsix_hyperlink", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Try the new analyzer extension!.
-        /// </summary>
-        internal static string Analyzer_vsix_try_description {
-            get {
-                return ResourceManager.GetString("Analyzer_vsix_try_description", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to AnalyzerChangedOnDisk.
         /// </summary>
@@ -1286,6 +1259,15 @@ internal static string Navigation_must_be_performed_on_the_foreground_thread {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Never show this again.
+        /// </summary>
+        internal static string Never_show_this_again {
+            get {
+                return ResourceManager.GetString("Never_show_this_again", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to New _file name:.
         /// </summary>
@@ -2167,6 +2149,16 @@ internal static string To_see_what_caused_the_issue_please_try_below_1_Close_Vis
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Try the preview version of our live code analysis extension, which provides more fixes for common API design, naming, performance, and reliability issues.
+        /// </summary>
+        internal static string Try_the_preview_version_of_our_live_code_analysis_extension_which_provides_more_fixes_for_common_API_design_naming_performance_and_reliability_issues {
+            get {
+                return ResourceManager.GetString("Try_the_preview_version_of_our_live_code_analysis_extension_which_provides_more_f" +
+                        "ixes_for_common_API_design_naming_performance_and_reliability_issues", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Type.
         /// </summary>
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index e6f90462b3d35..3c2d37950f4a4 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -912,13 +912,10 @@ Additional information: {1}</value>
   <data name="Options" xml:space="preserve">
     <value>Options</value>
   </data>
-  <data name="Analyzer_vsix_hyperlink" xml:space="preserve">
-    <value>Install</value>
+  <data name="Try_the_preview_version_of_our_live_code_analysis_extension_which_provides_more_fixes_for_common_API_design_naming_performance_and_reliability_issues" xml:space="preserve">
+    <value>Try the preview version of our live code analysis extension, which provides more fixes for common API design, naming, performance, and reliability issues</value>
   </data>
-  <data name="Analyzer_vsix_try_description" xml:space="preserve">
-    <value>Try the new analyzer extension!</value>
-  </data>
-  <data name="Analyzer_vsix_do_not_show_again" xml:space="preserve">
-    <value>Do not show again</value>
+  <data name="Never_show_this_again" xml:space="preserve">
+    <value>Never show this again</value>
   </data>
 </root>
\ No newline at end of file

From d4ba609bcd16339a6b8670d6734acbc8a23fe298 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Mon, 15 May 2017 16:27:39 -0700
Subject: [PATCH 241/284] Add ProjectReference guids

---
 src/Test/PdbUtilities/PdbUtilities.csproj | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/Test/PdbUtilities/PdbUtilities.csproj b/src/Test/PdbUtilities/PdbUtilities.csproj
index ba09f723d13e0..654b6e4471339 100644
--- a/src/Test/PdbUtilities/PdbUtilities.csproj
+++ b/src/Test/PdbUtilities/PdbUtilities.csproj
@@ -68,8 +68,14 @@
     <PackageReference Include="xunit.assert" Version="$(xunitassertVersion)" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\Compilers\Core\Portable\CodeAnalysis.csproj" />
-    <ProjectReference Include="..\Utilities\Portable\TestUtilities.csproj" />
+    <ProjectReference Include="..\..\Compilers\Core\Portable\CodeAnalysis.csproj">
+      <Project>{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}</Project>
+      <Name>CodeAnalysis</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Utilities\Portable\TestUtilities.csproj">
+      <Project>{ccbd3438-3e84-40a9-83ad-533f23bcfca5}</Project>
+      <Name>TestUtilities</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="..\..\..\build\Targets\Imports.targets" />
 </Project>
\ No newline at end of file

From 42135959666b4ee36f52828c2703eac88a93b157 Mon Sep 17 00:00:00 2001
From: Paul Vick <paulvick@hotmail.com>
Date: Mon, 15 May 2017 16:39:56 -0700
Subject: [PATCH 242/284] Fix up merge

---
 .../TestUtilities/CodeLens/AbstractCodeLensTest.cs              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/EditorFeatures/TestUtilities/CodeLens/AbstractCodeLensTest.cs b/src/EditorFeatures/TestUtilities/CodeLens/AbstractCodeLensTest.cs
index f0dfda0e9b261..050c55e33fc9e 100644
--- a/src/EditorFeatures/TestUtilities/CodeLens/AbstractCodeLensTest.cs
+++ b/src/EditorFeatures/TestUtilities/CodeLens/AbstractCodeLensTest.cs
@@ -106,7 +106,7 @@ protected static Task RunMethodReferenceTest(string input)
 
         protected static async Task RunFullyQualifiedNameTest(XElement input)
         {
-            using (var workspace = await TestWorkspace.CreateAsync(input))
+            using (var workspace = TestWorkspace.Create(input))
             {
                 foreach (var annotatedDocument in workspace.Documents.Where(d => d.AnnotatedSpans.Any()))
                 {

From dfae2e6510b512cf981868330dc5977d9026fdcc Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 17:28:39 -0700
Subject: [PATCH 243/284] Fix perf regression in gotodef.

---
 .../GoToDefinition/GoToDefinitionHelpers.cs   | 23 +++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/src/EditorFeatures/Core/GoToDefinition/GoToDefinitionHelpers.cs b/src/EditorFeatures/Core/GoToDefinition/GoToDefinitionHelpers.cs
index c76ae32e97509..fc576377d1294 100644
--- a/src/EditorFeatures/Core/GoToDefinition/GoToDefinitionHelpers.cs
+++ b/src/EditorFeatures/Core/GoToDefinition/GoToDefinitionHelpers.cs
@@ -61,8 +61,27 @@ public static bool TryGoToDefinition(
             }
 
             var definitions = ArrayBuilder<DefinitionItem>.GetInstance();
-            var definitionItem = symbol.ToClassifiedDefinitionItemAsync(
-                solution, includeHiddenLocations: true, cancellationToken: cancellationToken).WaitAndGetResult(cancellationToken);
+
+            // Going to a symbol may end up actually showing the symbol in the Find-Usages window.
+            // This happens when there is more than one location for the symbol (i.e. for partial
+            // symbols) and we don't know the best place to take you to.
+            //
+            // The FindUsages window supports showing the classified text for an item.  It does this
+            // in two ways.  Either the item can pass along its classified text (and the window will
+            // defer to that), or the item will have no classified text, and the window will compute
+            // it in the BG.
+            //
+            // Passing along the classified information is valuable for OOP scenarios where we want
+            // all that expensive computation done on the OOP side and not in the VS side.
+            // 
+            // However, Go To Definition is all in-process, and is also synchronous.  So we do not
+            // want to fetch the classifications here.  It slows down the command and leads to a 
+            // measurable delay in our perf tests.
+            // 
+            // So, if we only have a single location to go to, this does no unnecessary work.  And,
+            // if we do have multiple locations to show, it will just be done in the BG, unblocking
+            // this command thread so it can return the user faster.
+            var definitionItem = symbol.ToNonClassifiedDefinitionItem(solution, includeHiddenLocations: true);
 
             if (thirdPartyNavigationAllowed)
             {

From b77e2645f1f7e05cce4c89a230903ff25c05161f Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Mon, 15 May 2017 17:51:41 -0700
Subject: [PATCH 244/284] Convert if to switch.

---
 .../ContextQuery/SyntaxTokenExtensions.cs     | 131 ++++++++----------
 1 file changed, 56 insertions(+), 75 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/Extensions/ContextQuery/SyntaxTokenExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/ContextQuery/SyntaxTokenExtensions.cs
index 0500e4255c8ce..9dfae48094775 100644
--- a/src/Workspaces/CSharp/Portable/Extensions/ContextQuery/SyntaxTokenExtensions.cs
+++ b/src/Workspaces/CSharp/Portable/Extensions/ContextQuery/SyntaxTokenExtensions.cs
@@ -101,92 +101,73 @@ public static bool IsBeginningOfStatementContext(this SyntaxToken token)
 
             // for ( ; ; Foo(), |
 
-            if (token.Kind() == SyntaxKind.OpenBraceToken &&
-                token.Parent.IsKind(SyntaxKind.Block))
+            switch (token.Kind())
             {
-                return true;
-            }
-
-            if (token.Kind() == SyntaxKind.SemicolonToken)
-            {
-                var statement = token.GetAncestor<StatementSyntax>();
-                if (statement != null && !statement.IsParentKind(SyntaxKind.GlobalStatement) &&
-                    statement.GetLastToken(includeZeroWidth: true) == token)
-                {
+                case SyntaxKind.OpenBraceToken when token.Parent.IsKind(SyntaxKind.Block):
                     return true;
-                }
-            }
 
-            if (token.Kind() == SyntaxKind.CloseBraceToken &&
-                token.Parent.IsKind(SyntaxKind.Block))
-            {
-                if (token.Parent.Parent is StatementSyntax)
-                {
-                    // Most blocks that are the child of statement are places
-                    // that we can follow with another statement.  i.e.:
-                    // if { }
-                    // while () { }
-                    // There are two exceptions.
-                    // try {}
-                    // do {}
-                    if (!token.Parent.IsParentKind(SyntaxKind.TryStatement) &&
-                        !token.Parent.IsParentKind(SyntaxKind.DoStatement))
+                case SyntaxKind.SemicolonToken:
+                    var statement = token.GetAncestor<StatementSyntax>();
+                    return statement != null && !statement.IsParentKind(SyntaxKind.GlobalStatement) &&
+                           statement.GetLastToken(includeZeroWidth: true) == token;
+
+                case SyntaxKind.CloseBraceToken:
+                    if (token.Parent.IsKind(SyntaxKind.Block))
                     {
-                        return true;
+                        if (token.Parent.Parent is StatementSyntax)
+                        {
+                            // Most blocks that are the child of statement are places
+                            // that we can follow with another statement.  i.e.:
+                            // if { }
+                            // while () { }
+                            // There are two exceptions.
+                            // try {}
+                            // do {}
+                            if (!token.Parent.IsParentKind(SyntaxKind.TryStatement) &&
+                                !token.Parent.IsParentKind(SyntaxKind.DoStatement))
+                            {
+                                return true;
+                            }
+                        }
+                        else if (
+                            token.Parent.IsParentKind(SyntaxKind.ElseClause) ||
+                            token.Parent.IsParentKind(SyntaxKind.FinallyClause) ||
+                            token.Parent.IsParentKind(SyntaxKind.CatchClause) ||
+                            token.Parent.IsParentKind(SyntaxKind.SwitchSection))
+                        {
+                            return true;
+                        }
                     }
-                }
-                else if (
-                    token.Parent.IsParentKind(SyntaxKind.ElseClause) ||
-                    token.Parent.IsParentKind(SyntaxKind.FinallyClause) ||
-                    token.Parent.IsParentKind(SyntaxKind.CatchClause) ||
-                    token.Parent.IsParentKind(SyntaxKind.SwitchSection))
-                {
-                    return true;
-                }
-            }
 
-            if (token.Kind() == SyntaxKind.CloseBraceToken &&
-                token.Parent.IsKind(SyntaxKind.SwitchStatement))
-            {
-                return true;
-            }
+                    if (token.Parent.IsKind(SyntaxKind.SwitchStatement))
+                    {
+                        return true;
+                    }
 
-            if (token.Kind() == SyntaxKind.ColonToken)
-            {
-                if (token.Parent.IsKind(SyntaxKind.CaseSwitchLabel,
-                                        SyntaxKind.DefaultSwitchLabel,
-                                        SyntaxKind.CasePatternSwitchLabel,
-                                        SyntaxKind.LabeledStatement))
-                {
-                    return true;
-                }
-            }
+                    return false;
 
-            if (token.Kind() == SyntaxKind.DoKeyword &&
-                token.Parent.IsKind(SyntaxKind.DoStatement))
-            {
-                return true;
-            }
+                case SyntaxKind.ColonToken:
+                    return token.Parent.IsKind(SyntaxKind.CaseSwitchLabel,
+                                               SyntaxKind.DefaultSwitchLabel,
+                                               SyntaxKind.CasePatternSwitchLabel,
+                                               SyntaxKind.LabeledStatement);
 
-            if (token.Kind() == SyntaxKind.CloseParenToken)
-            {
-                var parent = token.Parent;
-                if (parent.IsKind(SyntaxKind.ForStatement) ||
-                    parent.IsKind(SyntaxKind.ForEachStatement) ||
-                    parent.IsKind(SyntaxKind.ForEachVariableStatement) ||
-                    parent.IsKind(SyntaxKind.WhileStatement) ||
-                    parent.IsKind(SyntaxKind.IfStatement) ||
-                    parent.IsKind(SyntaxKind.LockStatement) ||
-                    parent.IsKind(SyntaxKind.UsingStatement) ||
-                    parent.IsKind(SyntaxKind.FixedStatement))
-                {
+                case SyntaxKind.DoKeyword when token.Parent.IsKind(SyntaxKind.DoStatement):
                     return true;
-                }
-            }
 
-            if (token.Kind() == SyntaxKind.ElseKeyword)
-            {
-                return true;
+                case SyntaxKind.CloseParenToken:
+                    var parent = token.Parent;
+                    return parent.IsKind(SyntaxKind.ForStatement) ||
+                           parent.IsKind(SyntaxKind.ForEachStatement) ||
+                           parent.IsKind(SyntaxKind.ForEachVariableStatement) ||
+                           parent.IsKind(SyntaxKind.WhileStatement) ||
+                           parent.IsKind(SyntaxKind.IfStatement) ||
+                           parent.IsKind(SyntaxKind.LockStatement) ||
+                           parent.IsKind(SyntaxKind.UsingStatement) ||
+                           parent.IsKind(SyntaxKind.FixedStatement);
+
+                case SyntaxKind.ElseKeyword:
+                    return true;
             }
 
             return false;

From 8ea39b1432db3e8a1453429297a17cf765ef9097 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Mon, 15 May 2017 17:56:29 -0700
Subject: [PATCH 245/284] Addressed pr feedback.

---
 .../Experimentation/AnalyzerABTestOptions.cs             | 5 -----
 .../AnalyzerVsixSuggestedActionCallback.cs               | 9 +++++----
 2 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerABTestOptions.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerABTestOptions.cs
index f0ed5683e282d..d3a5116923821 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerABTestOptions.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerABTestOptions.cs
@@ -9,24 +9,19 @@ internal static class AnalyzerABTestOptions
     {
         private const string LocalRegistryPath = @"Roslyn\Internal\Analyzers\AB\Vsix\";
 
-        [ExportOption]
         public static readonly Option<long> LastDateTimeUsedSuggestionAction = new Option<long>(nameof(AnalyzerABTestOptions),
             nameof(LastDateTimeUsedSuggestionAction), defaultValue: DateTime.MinValue.ToBinary(),
             storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(LastDateTimeUsedSuggestionAction)));
 
-        [ExportOption]
         public static readonly Option<uint> UsedSuggestedActionCount = new Option<uint>(nameof(AnalyzerABTestOptions), nameof(UsedSuggestedActionCount),
             defaultValue: 0, storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(UsedSuggestedActionCount)));
 
-        [ExportOption]
         public static readonly Option<bool> NeverShowAgain = new Option<bool>(nameof(AnalyzerABTestOptions), nameof(NeverShowAgain),
             defaultValue: false, storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(NeverShowAgain)));
 
-        [ExportOption]
         public static readonly Option<bool> HasMetCandidacyRequirements = new Option<bool>(nameof(AnalyzerABTestOptions), nameof(HasMetCandidacyRequirements),
             defaultValue: false, storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(HasMetCandidacyRequirements)));
 
-        [ExportOption]
         public static readonly Option<long> LastDateTimeInfoBarShown = new Option<long>(nameof(AnalyzerABTestOptions), nameof(LastDateTimeInfoBarShown),
             defaultValue: DateTime.MinValue.ToBinary(),
             storageLocations: new LocalUserProfileStorageLocation(LocalRegistryPath + nameof(LastDateTimeInfoBarShown)));
diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
index c297f5fb45ef3..cd6671d25f44a 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -26,7 +26,7 @@ internal class AnalyzerVsixSuggestedActionCallback : ForegroundThreadAffinitized
         /// <summary>
         /// Tracks when the bar is shown so we don't show to the user more than once per session
         /// </summary>
-        private bool _infoBarShown = false;
+        private bool _infoBarChecked = false;
 
         /// <summary>
         /// This service is initialzed by <see cref="OnSuggestedActionExecuted(SuggestedAction)"/>
@@ -60,8 +60,8 @@ public void OnSuggestedActionExecuted(SuggestedAction action)
 
             // Only show if the VSIX is not installed, the info bar hasn't been shown this session,
             // and the user is an A/B test candidate
-            if (!IsVsixInstalled() &&
-                !_infoBarShown &&
+            if (!_infoBarChecked
+                !IsVsixInstalled() &&
                 IsCandidate())
             {
                 ShowInfoBarIfNecessary();
@@ -138,6 +138,8 @@ private bool IsCandidate()
 
         private void ShowInfoBarIfNecessary()
         {
+            // Only check for whether we should show an info bar once per session.
+            _infoBarChecked = true;
             if (_experimentationService.IsExperimentEnabled(AnalyzerEnabledFlight))
             {
                 // If we got true from the experimentation service, then we're in the treatment
@@ -149,7 +151,6 @@ private void ShowInfoBarIfNecessary()
 
                 if (timeSinceLastShown.TotalDays >= 1)
                 {
-                    _infoBarShown = true;
                     _workspace.Options = _workspace.Options.WithChangedOption(AnalyzerABTestOptions.LastDateTimeInfoBarShown, utcNow.ToBinary());
 
                     var infoBarService = _workspace.Services.GetRequiredService<IInfoBarService>();

From f88efe1207c0c8660ba6eb3037657545642c2748 Mon Sep 17 00:00:00 2001
From: Shyam N <gnamboo@microsoft.com>
Date: Mon, 15 May 2017 18:43:11 -0700
Subject: [PATCH 246/284] Add back 'beta2' nuget moniker for official builds.

---
 build/Targets/Versions.props | 1 +
 1 file changed, 1 insertion(+)

diff --git a/build/Targets/Versions.props b/build/Targets/Versions.props
index 3287c9342ed53..a69045eac38a6 100644
--- a/build/Targets/Versions.props
+++ b/build/Targets/Versions.props
@@ -15,6 +15,7 @@
     <!-- The release moniker for our packages.  Developers should use "dev" and official builds pick the branch
          moniker listed below -->
     <RoslynNuGetMoniker Condition="'$(RoslynNuGetMoniker)' == ''">dev</RoslynNuGetMoniker>
+    <RoslynNuGetMoniker Condition="'$(OfficialBuild)' == 'true'">beta2</RoslynNuGetMoniker>
     <!-- This is the base of the NuGet versioning for prerelease packages -->
     <NuGetPreReleaseVersion>$(RoslynFileVersionBase)-$(RoslynNuGetMoniker)</NuGetPreReleaseVersion>
 

From d591a62430f67cc3f7b3913b55e687a34faac826 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Mon, 15 May 2017 23:30:00 -0700
Subject: [PATCH 247/284] Add IL based tests for IArgument

---
 .../IOperation/IOperationTests_IArgument.cs   | 323 +++++++++++++++++-
 .../Utilities/CSharp/SemanticModelTestBase.cs |   9 +
 2 files changed, 326 insertions(+), 6 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index f853c86b6fe5d..7ea45576d1a3c 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -2,6 +2,7 @@
                                                                 
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests
@@ -133,7 +134,7 @@ static void M2(int x, double y = 0.0) { }
 
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
-        
+
         public void NamedArgumentInParameterOrderWithDefaultValue()
         {
             string source = @"
@@ -160,7 +161,7 @@ static void M2(int x = 1, int y = 2, int z = 3) { }
 
             VerifyOperationTreeAndDiagnosticsForTest<InvocationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
-        
+
         [Fact]
         public void NamedArgumentOutOfParameterOrderWithDefaultValue()
         {
@@ -978,7 +979,7 @@ void M2(string x )
   Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: null) (OperationKind.Argument, IsInvalid) (Syntax: '1')
       ILiteralExpression (Text: 1) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: '1')
 ";
-            var expectedDiagnostics = new DiagnosticDescription[] 
+            var expectedDiagnostics = new DiagnosticDescription[]
             {
                 // file.cs(6,22): error CS1503: Argument 1: cannot convert from 'int' to 'string'
                 //         /*<bind>*/M2(1)/*</bind>*/;
@@ -989,7 +990,7 @@ void M2(string x )
         }
 
         [Fact]
-        public void InvalidConversionForDefaultArgument()
+        public void InvalidConversionForDefaultArgument_InSource()
         {
             string source = @"
 class P
@@ -1020,7 +1021,7 @@ void M2(int x = ""string"")
 
         [Fact]
         public void AssigningToIndexer()
-        {                      
+        {
             string source = @"
 class P
 {
@@ -1080,7 +1081,7 @@ void M1()
 
         [Fact]
         public void DefaultArgumentForIndexerGetter()
-        {                     
+        {
             string source = @"
 class P
 {
@@ -1176,5 +1177,315 @@ void M1()
 
             VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
+
+        [ClrOnlyFact(ClrOnlyReason.Ilasm)]
+        public void AssigningToIndexer_UsingDefaultArgumentFromSetter()
+        {
+            var il = @"
+.class public auto ansi beforefieldinit P
+       extends [mscorlib]System.Object
+{
+  .custom instance void [mscorlib]System.Reflection.DefaultMemberAttribute::.ctor(string) 
+           = {string('Item')}
+
+  .method public hidebysig specialname rtspecialname 
+          instance void  .ctor() cil managed
+  {
+    // Code size       8 (0x8)
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
+    IL_0006:  nop
+    IL_0007:  ret
+  } // end of method P::.ctor
+
+  .method public hidebysig specialname instance int32 
+          get_Item([opt] int32 i,
+                   [opt] int32 j) cil managed
+  {
+    .param [1] = int32(0x00000001)
+    .param [2] = int32(0x00000002)
+    // Code size       7 (0x7)
+    .maxstack  1
+    .locals init ([0] int32 V_0)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.0
+    IL_0003:  br.s       IL_0005
+    IL_0005:  ldloc.0
+    IL_0006:  ret
+  } // end of method P::get_Item
+  
+  .method public hidebysig specialname instance void 
+          set_Item([opt] int32 i,
+                   [opt] int32 j,
+                   int32 'value') cil managed
+  {
+    .param [1] = int32(0x00000003)
+    .param [2] = int32(0x00000004)
+    // Code size       2 (0x2)
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ret
+  } // end of method P::set_Item
+
+
+  .property instance int32 Item(int32,
+                                int32)
+  {
+    .get instance int32 P::get_Item(int32,
+                                    int32)
+    .set instance void P::set_Item(int32,
+                                   int32,
+                                   int32)
+  } // end of property P::Item
+} // end of class P
+"; 
+
+            var csharp = @"
+class C
+{
+    public void M1()
+    {
+         P p = new P();
+         /*<bind>*/p[10]/*</bind>*/ = 9;
+    }
+}
+";
+            string expectedOperationTree = @"
+IIndexedPropertyReferenceExpression: System.Int32 P.this[[System.Int32 i = 3], [System.Int32 j = 4]] { get; set; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32) (Syntax: 'p[10]')
+  Instance Receiver: ILocalReferenceExpression: p (OperationKind.LocalReferenceExpression, Type: P) (Syntax: 'p')
+  Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: i) (OperationKind.Argument) (Syntax: '10')
+      ILiteralExpression (Text: 10) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 10) (Syntax: '10')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: j) (OperationKind.Argument) (Syntax: 'p[10]')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 4) (Syntax: 'p[10]')";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTestWithIL<ElementAccessExpressionSyntax>(csharp, il, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Ilasm)]
+        public void ReadFromIndexer_UsingDefaultArgumentFromGetter()
+        {
+            var il = @"
+.class public auto ansi beforefieldinit P
+       extends [mscorlib]System.Object
+{
+  .custom instance void [mscorlib]System.Reflection.DefaultMemberAttribute::.ctor(string) 
+           = {string('Item')}
+
+  .method public hidebysig specialname rtspecialname 
+          instance void  .ctor() cil managed
+  {
+    // Code size       8 (0x8)
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
+    IL_0006:  nop
+    IL_0007:  ret
+  } // end of method P::.ctor
+
+  .method public hidebysig specialname instance int32 
+          get_Item([opt] int32 i,
+                   [opt] int32 j) cil managed
+  {
+    .param [1] = int32(0x00000001)
+    .param [2] = int32(0x00000002)
+    // Code size       7 (0x7)
+    .maxstack  1
+    .locals init ([0] int32 V_0)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.0
+    IL_0003:  br.s       IL_0005
+    IL_0005:  ldloc.0
+    IL_0006:  ret
+  } // end of method P::get_Item
+  
+  .method public hidebysig specialname instance void 
+          set_Item([opt] int32 i,
+                   [opt] int32 j,
+                   int32 'value') cil managed
+  {
+    .param [1] = int32(0x00000003)
+    .param [2] = int32(0x00000004)
+    // Code size       2 (0x2)
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ret
+  } // end of method P::set_Item
+
+
+  .property instance int32 Item(int32,
+                                int32)
+  {
+    .get instance int32 P::get_Item(int32,
+                                    int32)
+    .set instance void P::set_Item(int32,
+                                   int32,
+                                   int32)
+  } // end of property P::Item
+} // end of class P
+";
+
+            var csharp = @"
+class C
+{
+    public void M1()
+    {
+         P p = new P();
+         var x = /*<bind>*/p[10]/*</bind>*/;
+    }
+}
+";
+            string expectedOperationTree = @"
+IIndexedPropertyReferenceExpression: System.Int32 P.this[[System.Int32 i = 3], [System.Int32 j = 4]] { get; set; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32) (Syntax: 'p[10]')
+  Instance Receiver: ILocalReferenceExpression: p (OperationKind.LocalReferenceExpression, Type: P) (Syntax: 'p')
+  Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: i) (OperationKind.Argument) (Syntax: '10')
+      ILiteralExpression (Text: 10) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 10) (Syntax: '10')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: j) (OperationKind.Argument) (Syntax: 'p[10]')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: 'p[10]')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTestWithIL<ElementAccessExpressionSyntax>(csharp, il, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Ilasm)]
+        public void IndexerAccess_LHSOfCompoundAssignment()
+        {
+            var il = @"
+.class public auto ansi beforefieldinit P
+       extends [mscorlib]System.Object
+{
+  .custom instance void [mscorlib]System.Reflection.DefaultMemberAttribute::.ctor(string) 
+           = {string('Item')}
+
+  .method public hidebysig specialname rtspecialname 
+          instance void  .ctor() cil managed
+  {
+    // Code size       8 (0x8)
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
+    IL_0006:  nop
+    IL_0007:  ret
+  } // end of method P::.ctor
+
+  .method public hidebysig specialname instance int32 
+          get_Item([opt] int32 i,
+                   [opt] int32 j) cil managed
+  {
+    .param [1] = int32(0x00000001)
+    .param [2] = int32(0x00000002)
+    // Code size       7 (0x7)
+    .maxstack  1
+    .locals init ([0] int32 V_0)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.0
+    IL_0003:  br.s       IL_0005
+    IL_0005:  ldloc.0
+    IL_0006:  ret
+  } // end of method P::get_Item
+  
+  .method public hidebysig specialname instance void 
+          set_Item([opt] int32 i,
+                   [opt] int32 j,
+                   int32 'value') cil managed
+  {
+    .param [1] = int32(0x00000003)
+    .param [2] = int32(0x00000004)
+    // Code size       2 (0x2)
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ret
+  } // end of method P::set_Item
+
+
+  .property instance int32 Item(int32,
+                                int32)
+  {
+    .get instance int32 P::get_Item(int32,
+                                    int32)
+    .set instance void P::set_Item(int32,
+                                   int32,
+                                   int32)
+  } // end of property P::Item
+} // end of class P
+";
+
+            var csharp = @"
+class C
+{
+    public void M1()
+    {
+         P p = new P();
+         /*<bind>*/p[10]/*</bind>*/ += 99;
+    }
+}
+";
+            string expectedOperationTree = @"
+IIndexedPropertyReferenceExpression: System.Int32 P.this[[System.Int32 i = 3], [System.Int32 j = 4]] { get; set; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32) (Syntax: 'p[10]')
+  Instance Receiver: ILocalReferenceExpression: p (OperationKind.LocalReferenceExpression, Type: P) (Syntax: 'p')
+  Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: i) (OperationKind.Argument) (Syntax: '10')
+      ILiteralExpression (Text: 10) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 10) (Syntax: '10')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: j) (OperationKind.Argument) (Syntax: 'p[10]')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: 'p[10]')";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTestWithIL<ElementAccessExpressionSyntax>(csharp, il, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Ilasm)]
+        public void InvalidConversionForDefaultArgument_InIL()
+        {
+            var il = @"
+.class public auto ansi beforefieldinit P
+       extends [mscorlib]System.Object
+{
+  .method public hidebysig specialname rtspecialname 
+          instance void  .ctor() cil managed
+  {
+    // Code size       8 (0x8)
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
+    IL_0006:  nop
+    IL_0007:  ret
+  } // end of method P::.ctor
+
+  .method public hidebysig instance void  M1([opt] int32 s) cil managed
+  {
+    .param [1] = ""abc""
+    // Code size       2 (0x2)
+    .maxstack  8
+    IL_0000: nop
+    IL_0001:  ret
+  } // end of method P::M1
+} // end of class P 
+";
+
+            var csharp = @"
+class C
+{
+    public void M2()
+    {
+         P p = new P();
+         /*<bind>*/p.M1()/*</bind>*/;
+    }
+}
+";
+            string expectedOperationTree = @"
+IInvocationExpression ( void P.M1([System.Int32 s = ""abc""])) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'p.M1()')
+  Instance Receiver: ILocalReferenceExpression: p(OperationKind.LocalReferenceExpression, Type: P)(Syntax: 'p')
+  Arguments(1): IArgument(ArgumentKind.DefaultValue, Matching Parameter: s)(OperationKind.Argument, IsInvalid)(Syntax: 'p.M1()')
+      IConversionExpression(ConversionKind.Invalid, Implicit)(OperationKind.ConversionExpression, Type: System.Int32, IsInvalid)(Syntax: 'p.M1()')
+        ILiteralExpression(OperationKind.LiteralExpression, Type: System.String, Constant: ""abc"")(Syntax: 'p.M1()')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTestWithIL<InvocationExpressionSyntax>(csharp, il, expectedOperationTree, expectedDiagnostics);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
index b3397356ab550..89a0a47e7f9ff 100644
--- a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
@@ -274,5 +274,14 @@ protected void VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(string test
             var compilation = CreateStandardCompilation(testSrc, references, sourceFileName: "file.cs", options: compilationOptions ?? TestOptions.ReleaseDll, parseOptions: parseOptions);
             VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(compilation, expectedOperationTree, expectedDiagnostics);
         }
+
+        protected void VerifyOperationTreeAndDiagnosticsForTestWithIL<TSyntaxNode>(string testSrc, string ilSource, string expectedOperationTree, DiagnosticDescription[] expectedDiagnostics, CSharpCompilationOptions compilationOptions = null, CSharpParseOptions parseOptions = null, MetadataReference[] additionalReferences = null)
+   where TSyntaxNode : SyntaxNode
+        {
+            CompileWithCustomILSource(testSrc, ilSource, compilation =>
+            {
+                VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(compilation, expectedOperationTree, expectedDiagnostics);
+            });
+        }  
     }
 }

From 7b3e3730c38b1b43ec8b12316fa8e7346a34b496 Mon Sep 17 00:00:00 2001
From: Fredric Silberberg <frsilb@microsoft.com>
Date: Tue, 16 May 2017 10:37:46 -0700
Subject: [PATCH 248/284] Fixed syntax error

---
 .../Experimentation/AnalyzerVsixSuggestedActionCallback.cs      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
index cd6671d25f44a..7b0c355ec6a67 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -60,7 +60,7 @@ public void OnSuggestedActionExecuted(SuggestedAction action)
 
             // Only show if the VSIX is not installed, the info bar hasn't been shown this session,
             // and the user is an A/B test candidate
-            if (!_infoBarChecked
+            if (!_infoBarChecked &&
                 !IsVsixInstalled() &&
                 IsCandidate())
             {

From 648070f6b032f573855cd2a1d6b91cd2d792367e Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Tue, 16 May 2017 11:05:06 -0700
Subject: [PATCH 249/284] Fix test verifier so it doesn't attemp to emit

---
 .../IOperation/IOperationTests_IArgument.cs        |  8 ++++----
 .../Test/Utilities/CSharp/CSharpTestBase.cs        | 14 +++++++++-----
 .../Test/Utilities/CSharp/SemanticModelTestBase.cs |  6 ++----
 3 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index 7ea45576d1a3c..1615cbe88cb81 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -1478,10 +1478,10 @@ public void M2()
 ";
             string expectedOperationTree = @"
 IInvocationExpression ( void P.M1([System.Int32 s = ""abc""])) (OperationKind.InvocationExpression, Type: System.Void) (Syntax: 'p.M1()')
-  Instance Receiver: ILocalReferenceExpression: p(OperationKind.LocalReferenceExpression, Type: P)(Syntax: 'p')
-  Arguments(1): IArgument(ArgumentKind.DefaultValue, Matching Parameter: s)(OperationKind.Argument, IsInvalid)(Syntax: 'p.M1()')
-      IConversionExpression(ConversionKind.Invalid, Implicit)(OperationKind.ConversionExpression, Type: System.Int32, IsInvalid)(Syntax: 'p.M1()')
-        ILiteralExpression(OperationKind.LiteralExpression, Type: System.String, Constant: ""abc"")(Syntax: 'p.M1()')
+  Instance Receiver: ILocalReferenceExpression: p (OperationKind.LocalReferenceExpression, Type: P) (Syntax: 'p')
+  Arguments(1): IArgument (ArgumentKind.DefaultValue, Matching Parameter: s) (OperationKind.Argument, IsInvalid) (Syntax: 'p.M1()')
+      IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: System.Int32, IsInvalid) (Syntax: 'p.M1()')
+        ILiteralExpression (OperationKind.LiteralExpression, Type: System.String, Constant: ""abc"") (Syntax: 'p.M1()')
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
diff --git a/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs b/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
index 917788c4d65bb..562cb3ab6b606 100644
--- a/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
@@ -666,11 +666,7 @@ public CompilationVerifier CompileWithCustomILSource(string cSharpSource, string
                 return CompileAndVerify(c, expectedOutput: expectedOutput);
             }
 
-            MetadataReference reference = null;
-            using (var tempAssembly = IlasmUtilities.CreateTempAssembly(ilSource))
-            {
-                reference = MetadataReference.CreateFromImage(ReadFromFile(tempAssembly.Path));
-            }
+            MetadataReference reference = CreateMetadataReferenceFromIlSource(ilSource);
 
             var compilation = CreateStandardCompilation(cSharpSource, new[] { reference }, compilationOptions);
             compilationVerifier?.Invoke(compilation);
@@ -678,6 +674,14 @@ public CompilationVerifier CompileWithCustomILSource(string cSharpSource, string
             return CompileAndVerify(compilation, expectedOutput: expectedOutput);
         }
 
+        public static MetadataReference CreateMetadataReferenceFromIlSource(string ilSource)
+        {                                        
+            using (var tempAssembly = IlasmUtilities.CreateTempAssembly(ilSource))
+            {
+                return MetadataReference.CreateFromImage(ReadFromFile(tempAssembly.Path));
+            }
+        }
+
         protected override Compilation GetCompilationForEmit(
             IEnumerable<string> source,
             IEnumerable<MetadataReference> additionalRefs,
diff --git a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
index 89a0a47e7f9ff..9d63fcee5b3ab 100644
--- a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
@@ -278,10 +278,8 @@ protected void VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(string test
         protected void VerifyOperationTreeAndDiagnosticsForTestWithIL<TSyntaxNode>(string testSrc, string ilSource, string expectedOperationTree, DiagnosticDescription[] expectedDiagnostics, CSharpCompilationOptions compilationOptions = null, CSharpParseOptions parseOptions = null, MetadataReference[] additionalReferences = null)
    where TSyntaxNode : SyntaxNode
         {
-            CompileWithCustomILSource(testSrc, ilSource, compilation =>
-            {
-                VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(compilation, expectedOperationTree, expectedDiagnostics);
-            });
+            var ilReference = CreateMetadataReferenceFromIlSource(ilSource);
+            VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(testSrc, expectedOperationTree, expectedDiagnostics, compilationOptions, parseOptions, new[] { ilReference });
         }  
     }
 }

From fdd0c5a0286957a4826e3f15bef6d7b23634feff Mon Sep 17 00:00:00 2001
From: Tom Meschter <tom.meschter@microsoft.com>
Date: Tue, 16 May 2017 11:25:49 -0700
Subject: [PATCH 250/284] Check for missing hierarchies when mapping to Roslyn
 projects

Fixes #19517.

In order to shows the "Analyzers" node under the "References" node in
Solution Explorer and show the correct sets of analyzer assemblies and
diagnostics, we need to map the node for the project to the actual
Roslyn `AbstractProject` instance. This is done by matching up various
properties of the `IVsHierarchy` for the node to the same properties on
the `IVsHierarchy` returned by `AbstractProject.Hierarchy`.

This code path was initially written this `Hierarchy` property would
never return null; its value was supplied by the project system.
However, Delayed Project Load (DPL) bypasses the project system until
the user expands the project node in Solution Explorer, and as a result
we may now encounter `AbstractProjects` where `Hierarchy` returns null.
Currently if we run across one of these we'll throw a
`NullReferenceException` which has the end effect of preventing the
user from expanding the project node in Solution Explorer, and may even
result in a crash.

This commit adds in the null check. If the `Hierarchy` property is null
then it can't be the project we're looking for.
---
 .../Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs   | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs b/src/VisualStudio/Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs
index 4932a8941a31c..1e1853a4f4439 100644
--- a/src/VisualStudio/Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs
+++ b/src/VisualStudio/Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs
@@ -62,7 +62,8 @@ public bool TryGetProjectId(IVsHierarchyItem hierarchyItem, string targetFramewo
                         // project files are in the same folder--they both use the full path to the _folder_ as the canonical
                         // name. To distinguish them we also examine the "regular" name, which will necessarily be different
                         // if the two projects are in the same folder.
-                        if (p.Hierarchy.TryGetCanonicalName((uint)VSConstants.VSITEMID.Root, out string projectCanonicalName)
+                        if (p.Hierarchy != null
+                            && p.Hierarchy.TryGetCanonicalName((uint)VSConstants.VSITEMID.Root, out string projectCanonicalName)
                             && p.Hierarchy.TryGetItemName((uint)VSConstants.VSITEMID.Root, out string projectName)
                             && projectCanonicalName.Equals(nestedCanonicalName, System.StringComparison.OrdinalIgnoreCase)
                             && projectName.Equals(nestedName))

From be202cff85625463f7631c73ee6f6d3a0c7a2e75 Mon Sep 17 00:00:00 2001
From: Tom Meschter <tom.meschter@microsoft.com>
Date: Tue, 16 May 2017 12:08:27 -0700
Subject: [PATCH 251/284] Update comment

Update the code comment to explain why we need to check for null.
---
 .../Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs    | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/VisualStudio/Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs b/src/VisualStudio/Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs
index 1e1853a4f4439..fc9987148d90c 100644
--- a/src/VisualStudio/Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs
+++ b/src/VisualStudio/Core/SolutionExplorerShim/HierarchyItemToProjectIdMap.cs
@@ -62,6 +62,8 @@ public bool TryGetProjectId(IVsHierarchyItem hierarchyItem, string targetFramewo
                         // project files are in the same folder--they both use the full path to the _folder_ as the canonical
                         // name. To distinguish them we also examine the "regular" name, which will necessarily be different
                         // if the two projects are in the same folder.
+                        // Note that if a project has been loaded with Lightweight Solution Load it won't even have a
+                        // hierarchy, so we need to check for null first.
                         if (p.Hierarchy != null
                             && p.Hierarchy.TryGetCanonicalName((uint)VSConstants.VSITEMID.Root, out string projectCanonicalName)
                             && p.Hierarchy.TryGetItemName((uint)VSConstants.VSITEMID.Root, out string projectName)

From 2ccd49661b2e6fe82e360e0db15b3f70d9ad9c31 Mon Sep 17 00:00:00 2001
From: Ivan Basov <basov@hotmail.com>
Date: Tue, 16 May 2017 12:13:01 -0700
Subject: [PATCH 252/284] support CasePatternSwitchLabel in
 StatementSyntaxComparer (#19164)

---
 .../EditAndContinue/RudeEditStatementTests.cs | 18 ++++++---------
 .../StatementSyntaxComparer.cs                | 23 +++++++++++++++++++
 .../Core/Portable/Differencing/Match.cs       |  2 ++
 3 files changed, 32 insertions(+), 11 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/EditAndContinue/RudeEditStatementTests.cs b/src/EditorFeatures/CSharpTest/EditAndContinue/RudeEditStatementTests.cs
index 152b61439997e..56a2f0638357a 100644
--- a/src/EditorFeatures/CSharpTest/EditAndContinue/RudeEditStatementTests.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/RudeEditStatementTests.cs
@@ -1483,7 +1483,6 @@ public void InterpolationFormatClause_update()
             edits.VerifyEdits("Update [x = $\"Hello{123:N1}\"]@8 -> [x = $\"Hello{123:N2}\"]@8");
         }
 
-        [WorkItem(18970, "https://github.com/dotnet/roslyn/issues/18970")]
         [Fact]
         public void MatchCasePattern_UpdateDelete()
         {
@@ -1507,9 +1506,9 @@ public void MatchCasePattern_UpdateDelete()
 
             var expected = new MatchingPairs {
                 { "switch(shape) {     case Point p: return 0;     case Circle c: return 1; }", "switch(shape) {     case Circle circle: return 1; }" },
-                { "p", "circle" },
                 { "case Circle c: return 1;", "case Circle circle: return 1;" },
                 { "case Circle c:", "case Circle circle:" },
+                { "c", "circle" },
                 { "return 1;", "return 1;" }
             };
 
@@ -1716,7 +1715,6 @@ public void Switch_Case_Update()
                 "Update [case 1: f(); break;]@18 -> [case 2: f(); break;]@18");
         }
 
-        [WorkItem(18970, "https://github.com/dotnet/roslyn/issues/18970")]
         [Fact]
         public void CasePatternLabel_UpdateDelete()
         {
@@ -1739,12 +1737,11 @@ public void CasePatternLabel_UpdateDelete()
 
             edits.VerifyEdits(
                 "Update [case Circle c: return 1;]@55 -> [case Circle circle: return 1;]@26",
-                "Update [p]@37 -> [circle]@38",
-                "Move [p]@37 -> @38",
+                "Update [c]@67 -> [circle]@38",
                 "Delete [case Point p: return 0;]@26",
                 "Delete [case Point p:]@26",
-                "Delete [return 0;]@40",
-                "Delete [c]@67");
+                "Delete [p]@37",
+                "Delete [return 0;]@40");
         }
 
         #endregion
@@ -8423,12 +8420,11 @@ public void CasePattern_UpdateDelete()
             edits.VerifyEdits(
                 "Update [case Circle c: A(c); break;]@55 -> [case Circle c1: A(c1); break;]@26",
                 "Update [A(c);]@70 -> [A(c1);]@42",
-                "Update [p]@37 -> [c1]@38",
-                "Move [p]@37 -> @38",
+                "Update [c]@67 -> [c1]@38",
                 "Delete [case Point p: return 0;]@26",
                 "Delete [case Point p:]@26",
-                "Delete [return 0;]@40",
-                "Delete [c]@67");
+                "Delete [p]@37",
+                "Delete [return 0;]@40");
         }
 
         [Fact]
diff --git a/src/Features/CSharp/Portable/EditAndContinue/StatementSyntaxComparer.cs b/src/Features/CSharp/Portable/EditAndContinue/StatementSyntaxComparer.cs
index cb58a82f1cf29..dc0b3d3ef1c01 100644
--- a/src/Features/CSharp/Portable/EditAndContinue/StatementSyntaxComparer.cs
+++ b/src/Features/CSharp/Portable/EditAndContinue/StatementSyntaxComparer.cs
@@ -681,6 +681,10 @@ protected override bool TryComputeWeightedDistance(SyntaxNode leftNode, SyntaxNo
                     distance = (leftNode.RawKind == rightNode.RawKind) ? 0.0 : 0.1;
                     return true;
 
+                case SyntaxKind.SingleVariableDesignation:
+                    distance = ComputeWeightedDistance((SingleVariableDesignationSyntax)leftNode, (SingleVariableDesignationSyntax)rightNode);
+                    return true;
+
                 default:
                     distance = 0;
                     return false;
@@ -837,6 +841,25 @@ private bool TryComputeWeightedDistance(BlockSyntax leftBlock, BlockSyntax right
             }
         }
 
+        private double ComputeWeightedDistance(SingleVariableDesignationSyntax leftNode, SingleVariableDesignationSyntax rightNode)
+        {
+            double distance = ComputeDistance(leftNode, rightNode);
+            double parentDistance;
+
+            if (leftNode.Parent != null && 
+                rightNode.Parent != null &&
+                GetLabel(leftNode.Parent) == GetLabel(rightNode.Parent))
+            {
+                parentDistance = ComputeDistance(leftNode.Parent, rightNode.Parent);
+            }
+            else
+            {
+                parentDistance = 1;
+            }
+
+            return 0.5 * parentDistance + 0.5 * distance;
+        }
+
         private static double ComputeWeightedBlockDistance(BlockSyntax leftBlock, BlockSyntax rightBlock)
         {
             if (TryComputeLocalsDistance(leftBlock, rightBlock, out var distance))
diff --git a/src/Workspaces/Core/Portable/Differencing/Match.cs b/src/Workspaces/Core/Portable/Differencing/Match.cs
index 69f12c4672393..0c891a27393a4 100644
--- a/src/Workspaces/Core/Portable/Differencing/Match.cs
+++ b/src/Workspaces/Core/Portable/Differencing/Match.cs
@@ -14,6 +14,7 @@ public sealed partial class Match<TNode>
         private const double EpsilonDistance = 0.00001;
         private const double MatchingDistance1 = 0.25;
         private const double MatchingDistance2 = 0.5;
+        private const double MatchingDistance3 = 0.75;
         private const double MaxDistance = 1.0;
 
         private readonly TreeComparer<TNode> _comparer;
@@ -153,6 +154,7 @@ private void ComputeMatchForLabel(int label, List<TNode> s1, List<TNode> s2)
             ComputeMatchForLabel(s1, s2, tiedToAncestor, EpsilonDistance);     // almost exact match
             ComputeMatchForLabel(s1, s2, tiedToAncestor, MatchingDistance1);   // ok match
             ComputeMatchForLabel(s1, s2, tiedToAncestor, MatchingDistance2);   // ok match
+            ComputeMatchForLabel(s1, s2, tiedToAncestor, MatchingDistance3);   // ok match
             ComputeMatchForLabel(s1, s2, tiedToAncestor, MaxDistance);         // any match
         }
 

From c0e5a047be37ad04f6c6eba504703adf5f35e13d Mon Sep 17 00:00:00 2001
From: Alireza Habibi <habibi.alireza@outlook.com>
Date: Tue, 16 May 2017 01:02:02 +0430
Subject: [PATCH 253/284] Clean up SyntaxNodeExtensions

---
 .../Shared/Extensions/SyntaxNodeExtensions.cs | 47 +++++--------------
 1 file changed, 13 insertions(+), 34 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxNodeExtensions.cs b/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxNodeExtensions.cs
index deab34278b90f..fefb84772103a 100644
--- a/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxNodeExtensions.cs
+++ b/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxNodeExtensions.cs
@@ -5,7 +5,6 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
@@ -26,9 +25,7 @@ public static IEnumerable<SyntaxNode> GetAncestors(this SyntaxNode node)
             {
                 yield return current;
 
-                current = current is IStructuredTriviaSyntax
-                    ? ((IStructuredTriviaSyntax)current).ParentTrivia.Token.Parent
-                    : current.Parent;
+                current = current.GetParent();
             }
         }
 
@@ -43,32 +40,20 @@ public static IEnumerable<TNode> GetAncestors<TNode>(this SyntaxNode node)
                     yield return tNode;
                 }
 
-                current = current is IStructuredTriviaSyntax
-                    ? ((IStructuredTriviaSyntax)current).ParentTrivia.Token.Parent
-                    : current.Parent;
+                current = current.GetParent();
             }
         }
 
         public static TNode GetAncestor<TNode>(this SyntaxNode node)
             where TNode : SyntaxNode
         {
-            if (node == null)
-            {
-                return default(TNode);
-            }
-
-            return node.GetAncestors<TNode>().FirstOrDefault();
+            return node?.GetAncestors<TNode>().FirstOrDefault();
         }
 
         public static TNode GetAncestorOrThis<TNode>(this SyntaxNode node)
             where TNode : SyntaxNode
         {
-            if (node == null)
-            {
-                return default(TNode);
-            }
-
-            return node.GetAncestorsOrThis<TNode>().FirstOrDefault();
+            return node?.GetAncestorsOrThis<TNode>().FirstOrDefault();
         }
 
         public static IEnumerable<TNode> GetAncestorsOrThis<TNode>(this SyntaxNode node)
@@ -82,9 +67,7 @@ public static IEnumerable<TNode> GetAncestorsOrThis<TNode>(this SyntaxNode node)
                     yield return tNode;
                 }
 
-                current = current is IStructuredTriviaSyntax
-                    ? ((IStructuredTriviaSyntax)current).ParentTrivia.Token.Parent
-                    : current.Parent;
+                current = current.GetParent();
             }
         }
 
@@ -122,12 +105,7 @@ public static IEnumerable<TSyntaxNode> Traverse<TSyntaxNode>(
 
         public static bool CheckParent<T>(this SyntaxNode node, Func<T, bool> valueChecker) where T : SyntaxNode
         {
-            if (node == null)
-            {
-                return false;
-            }
-
-            var parentNode = node.Parent as T;
+            var parentNode = node?.Parent as T;
             if (parentNode == null)
             {
                 return false;
@@ -208,7 +186,7 @@ public static SyntaxNode FindInnermostCommonNode(
                     : blocks.Intersect(node.AncestorsAndSelf().Where(predicate));
             }
 
-            return blocks == null ? null : blocks.First();
+            return blocks?.First();
         }
 
         public static TSyntaxNode FindInnermostCommonNode<TSyntaxNode>(this IEnumerable<SyntaxNode> nodes)
@@ -276,9 +254,7 @@ public static IEnumerable<TextSpan> GetContiguousSpans(
                 }
                 else
                 {
-                    var lastToken = getLastToken == null
-                        ? lastNode.GetLastToken()
-                        : getLastToken(lastNode);
+                    var lastToken = getLastToken?.Invoke(lastNode) ?? lastNode.GetLastToken();
                     if (lastToken.GetNextToken(includeDirectives: true) == node.GetFirstToken())
                     {
                         // Expand the span
@@ -695,8 +671,6 @@ public static SyntaxToken FindTokenOnLeftOfPosition(
             return token;
         }
 
-
-
         public static T WithPrependedLeadingTrivia<T>(
             this T node,
             params SyntaxTrivia[] trivia) where T : SyntaxNode
@@ -772,5 +746,10 @@ public static T With<T>(
         {
             return node.WithLeadingTrivia(leadingTrivia).WithTrailingTrivia(trailingTrivia);
         }
+
+        private static SyntaxNode GetParent(this SyntaxNode node)
+        {
+            return node is IStructuredTriviaSyntax trivia ? trivia.ParentTrivia.Token.Parent : node.Parent;
+        }
     }
 }
\ No newline at end of file

From f907560dd642cba65f4d5d9d282ce4d5de0c6c8b Mon Sep 17 00:00:00 2001
From: Alireza Habibi <habibi.alireza@outlook.com>
Date: Wed, 17 May 2017 00:04:23 +0430
Subject: [PATCH 254/284] Do not leak out of the argument list when looking for
 an argument

---
 .../UseNamedArgumentsTests.vb                 | 11 +++++++++++
 ...seNamedArgumentsCodeRefactoringProvider.cs |  7 +++++--
 ...seNamedArgumentsCodeRefactoringProvider.cs | 15 +++++++++++----
 ...seNamedArgumentsCodeRefactoringProvider.vb |  4 ++++
 .../Shared/Extensions/SyntaxNodeExtensions.cs | 19 +++++++++++++++++++
 5 files changed, 50 insertions(+), 6 deletions(-)

diff --git a/src/EditorFeatures/VisualBasicTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.vb b/src/EditorFeatures/VisualBasicTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.vb
index 3ea58433b8a52..49768e6e8ef1a 100644
--- a/src/EditorFeatures/VisualBasicTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/CodeActions/UseNamedArguments/UseNamedArgumentsTests.vb
@@ -312,6 +312,17 @@ End Class")
     Sub M(arg1 As Integer, optional arg2 As Integer=1, optional arg3 as Integer=1)
         M(1[||],,3)
     End Sub
+End Class")
+        End Function
+
+        <WorkItem(19175, "https://github.com/dotnet/roslyn/issues/19175")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseNamedArguments)>
+        Public Async Function TestCaretPositionAtTheEnd5() As Task
+            Await TestMissingInRegularAndScriptAsync(
+"Class C
+    Function M(arg1 As Integer, optional arg2 As Integer=1, optional arg3 as Integer=1) As Integer
+        M(1, M(1,[||], 3))
+    End Function
 End Class")
         End Function
     End Class
diff --git a/src/Features/CSharp/Portable/CodeRefactorings/UseNamedArguments/CSharpUseNamedArgumentsCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/CodeRefactorings/UseNamedArguments/CSharpUseNamedArgumentsCodeRefactoringProvider.cs
index b03f01927fdb3..79fcabb748b74 100644
--- a/src/Features/CSharp/Portable/CodeRefactorings/UseNamedArguments/CSharpUseNamedArgumentsCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/CodeRefactorings/UseNamedArguments/CSharpUseNamedArgumentsCodeRefactoringProvider.cs
@@ -19,11 +19,14 @@ private abstract class BaseAnalyzer<TSyntax, TSyntaxList> : Analyzer<TSyntax, TS
             where TSyntax : SyntaxNode
             where TSyntaxList : SyntaxNode 
         {
-            protected override SyntaxNode GetReceiver(SyntaxNode argument)
+            protected sealed override SyntaxNode GetReceiver(SyntaxNode argument)
                 => argument.Parent.Parent;
 
-            protected override bool IsLegalToAddNamedArguments(ImmutableArray<IParameterSymbol> parameters, int argumentCount)
+            protected sealed override bool IsLegalToAddNamedArguments(ImmutableArray<IParameterSymbol> parameters, int argumentCount)
                 => !parameters.Last().IsParams || parameters.Length >= argumentCount;
+
+            protected sealed override bool IsCloseParenOrComma(SyntaxToken token)
+                => token.IsKind(SyntaxKind.CloseParenToken, SyntaxKind.CommaToken);
         }
 
         private class ArgumentAnalyzer :
diff --git a/src/Features/Core/Portable/CodeRefactorings/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs b/src/Features/Core/Portable/CodeRefactorings/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs
index e413f51593f6b..1b2285bd00077 100644
--- a/src/Features/Core/Portable/CodeRefactorings/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/CodeRefactorings/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs
@@ -34,13 +34,19 @@ public async Task ComputeRefactoringsAsync(
                     return;
                 }
 
-                var token = root.FindToken(context.Span.Start);
-                if (token.ValueText == ")" || token.ValueText == ",")
+                var position = context.Span.Start;
+                var token = root.FindToken(position);
+                if (token.Span.Start == position &&
+                    IsCloseParenOrComma(token))
                 {
                     token = token.GetPreviousToken();
+                    if (token.Span.End != position)
+                    {
+                        return;
+                    }
                 }
 
-                var argument = root.FindNode(token.Span).FirstAncestorOrSelf<TBaseArgumentSyntax>() as TArgumentSyntax;
+                var argument = root.FindNode(token.Span).FirstAncestorOrSelfUntil<TBaseArgumentSyntax>(node => node is TArgumentListSyntax) as TArgumentSyntax;
                 if (argument == null)
                 {
                     return;
@@ -57,7 +63,7 @@ public async Task ComputeRefactoringsAsync(
                 var sourceText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
 
                 var argumentStartLine = sourceText.Lines.GetLineFromPosition(argument.Span.Start).LineNumber;
-                var caretLine = sourceText.Lines.GetLineFromPosition(context.Span.Start).LineNumber;
+                var caretLine = sourceText.Lines.GetLineFromPosition(position).LineNumber;
 
                 if (argumentStartLine != caretLine)
                 {
@@ -147,6 +153,7 @@ private TArgumentListSyntax GetOrSynthesizeNamedArguments(
             protected abstract TArgumentListSyntax WithArguments(
                 TArgumentListSyntax argumentList, IEnumerable<TBaseArgumentSyntax> namedArguments, IEnumerable<SyntaxToken> separators);
 
+            protected abstract bool IsCloseParenOrComma(SyntaxToken token);
             protected abstract bool IsLegalToAddNamedArguments(ImmutableArray<IParameterSymbol> parameters, int argumentCount);
             protected abstract TArgumentSyntax WithName(TArgumentSyntax argument, string name);
             protected abstract bool IsPositionalArgument(TArgumentSyntax argument);
diff --git a/src/Features/VisualBasic/Portable/CodeRefactorings/UseNamedArguments/VisualBasicUseNamedArgumentsCodeRefactoringProvider.vb b/src/Features/VisualBasic/Portable/CodeRefactorings/UseNamedArguments/VisualBasicUseNamedArgumentsCodeRefactoringProvider.vb
index fe0e34fcc1821..a9dd63ef72ee2 100644
--- a/src/Features/VisualBasic/Portable/CodeRefactorings/UseNamedArguments/VisualBasicUseNamedArgumentsCodeRefactoringProvider.vb
+++ b/src/Features/VisualBasic/Portable/CodeRefactorings/UseNamedArguments/VisualBasicUseNamedArgumentsCodeRefactoringProvider.vb
@@ -43,6 +43,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings.UseNamedArguments
             Protected Overrides Function IsLegalToAddNamedArguments(parameters As ImmutableArray(Of IParameterSymbol), argumentCount As Integer) As Boolean
                 Return Not parameters.LastOrDefault().IsParams OrElse parameters.Length > argumentCount
             End Function
+
+            Protected Overrides Function IsCloseParenOrComma(token As SyntaxToken) As Boolean
+                Return token.IsKind(SyntaxKind.CloseParenToken, SyntaxKind.CommaToken)
+            End Function
         End Class
 
         Public Sub New()
diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxNodeExtensions.cs b/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxNodeExtensions.cs
index fefb84772103a..d6760b2fab06f 100644
--- a/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxNodeExtensions.cs
+++ b/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxNodeExtensions.cs
@@ -751,5 +751,24 @@ private static SyntaxNode GetParent(this SyntaxNode node)
         {
             return node is IStructuredTriviaSyntax trivia ? trivia.ParentTrivia.Token.Parent : node.Parent;
         }
+
+        public static TNode FirstAncestorOrSelfUntil<TNode>(this SyntaxNode node, Func<SyntaxNode, bool> predicate)
+            where TNode : SyntaxNode
+        {
+            for (var current = node; current != null; current = current.GetParent())
+            {
+                if (current is TNode tnode)
+                {
+                    return tnode;
+                }
+
+                if (predicate(current))
+                {
+                    break;
+                }
+            }
+
+            return default(TNode);
+        }
     }
 }
\ No newline at end of file

From ea88bf6075ae2b4fb2f220c44a549fa893920e8c Mon Sep 17 00:00:00 2001
From: Ivan Basov <basov@hotmail.com>
Date: Tue, 16 May 2017 12:44:45 -0700
Subject: [PATCH 255/284] Migrate BasicExpressionEvaluator Integration Tests
 from Tao (#19529)

---
 .../VisualBasic/BasicExpressionEvaluator.cs   | 150 ++++++++++++++++++
 .../VisualStudioIntegrationTests.csproj       |   1 +
 .../InProcess/LocalsWindow_InProc.cs          |  58 ++++++-
 .../LocalsWindow_OutOfProc.Verifier.cs        |  13 ++
 4 files changed, 214 insertions(+), 8 deletions(-)
 create mode 100644 src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicExpressionEvaluator.cs

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicExpressionEvaluator.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicExpressionEvaluator.cs
new file mode 100644
index 0000000000000..d8b970dc05d18
--- /dev/null
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicExpressionEvaluator.cs
@@ -0,0 +1,150 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.VisualStudio.IntegrationTest.Utilities;
+using Xunit;
+using ProjectUtils = Microsoft.VisualStudio.IntegrationTest.Utilities.Common.ProjectUtils;
+
+namespace Roslyn.VisualStudio.IntegrationTests.VisualBasic
+{
+    [Collection(nameof(SharedIntegrationHostFixture))]
+    public class BasicExpressionEvaluator : AbstractEditorTest
+    {
+        protected override string LanguageName => LanguageNames.VisualBasic;
+
+        public BasicExpressionEvaluator(VisualStudioInstanceFactory instanceFactory) : base(instanceFactory)
+        {
+            VisualStudio.SolutionExplorer.CreateSolution(nameof(BasicBuild));
+            var testProj = new ProjectUtils.Project("TestProj");
+            VisualStudio.SolutionExplorer.AddProject(testProj, WellKnownProjectTemplates.ConsoleApplication, LanguageNames.VisualBasic);
+
+            VisualStudio.Editor.SetText(@"Imports System
+
+Module Module1
+
+    Sub Main()
+        Dim mySByte As SByte = SByte.MaxValue / 2
+        Dim myShort As Short = Short.MaxValue / 2
+        Dim myInt As Integer = Integer.MaxValue / 2
+        Dim myLong As Long = Long.MaxValue / 2
+
+        Dim myByte As Byte = Byte.MaxValue / 2
+        Dim myUShort As UShort = UShort.MaxValue / 2
+        Dim myUInt As UInteger = UInteger.MaxValue / 2
+        Dim myULong As ULong = ULong.MaxValue / 2
+
+        Dim myFloat As Single = Single.MaxValue / 2
+        Dim myDouble As Double = Double.MaxValue / 2
+        Dim myDecimal As Decimal = Decimal.MaxValue / 2
+
+        Dim myChar As Char = ""A""c
+        Dim myBool As Boolean = True
+
+        Dim myObject As Object = Nothing
+        Dim myString As String = String.Empty
+
+        Dim myValueType As System.ValueType = myShort
+        Dim myEnum As System.Enum = Nothing
+        Dim myArray As System.Array = Nothing
+        Dim myDelegate As System.Delegate = Nothing
+        Dim myMulticastDelegate As System.MulticastDelegate = Nothing
+
+        System.Diagnostics.Debugger.Break()
+    End Sub
+
+End Module");
+        }
+
+        [Fact]
+        public void ValidateLocalsWindow()
+        {
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+
+            VisualStudio.LocalsWindow.Verify.CheckCount(20);
+            VisualStudio.LocalsWindow.Verify.CheckEntry("mySByte", "SByte", "64");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myShort", "Short", "16384");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myInt", "Integer", "1073741824");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myLong", "Long", "4611686018427387904");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myByte", "Byte", "128");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myUShort", "UShort", "32768");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myUInt", "UInteger", "2147483648");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myULong", "ULong", "9223372036854775808");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myFloat", "Single", "1.70141173E+38");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myDouble", "Double", "8.9884656743115785E+307");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myDecimal", "Decimal", "39614081257132168796771975168");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myChar", "Char", "\"A\"c");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myBool", "Boolean", "True");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myObject", "Object", "Nothing");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myString", "String", "\"\"");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myValueType", "System.ValueType {Short}", "16384");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myEnum", "System.Enum", "Nothing");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myArray", "System.Array", "Nothing");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myDelegate", "System.Delegate", "Nothing");
+            VisualStudio.LocalsWindow.Verify.CheckEntry("myMulticastDelegate", "System.MulticastDelegate", "Nothing");
+        }
+
+        [Fact]
+        public void EvaluatePrimitiveValues()
+        {
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+
+            // It is better to use the Immediate Window but DTE does not provide an access to it.
+            VisualStudio.Debugger.CheckExpression("myByte", "Byte", "128");
+            VisualStudio.Debugger.CheckExpression("myFloat", "Single", "1.70141173E+38");
+            VisualStudio.Debugger.CheckExpression("myChar", "Char", "\"A\"c");
+            VisualStudio.Debugger.CheckExpression("myObject", "Object", "Nothing");
+            VisualStudio.Debugger.CheckExpression("myString", "String", "\"\"");
+        }
+
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/19526")]
+        public void EvaluateLambdaExpressions()
+        {
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+            // It is better to use the Immediate Window but DTE does not provide an access to it.
+            VisualStudio.Debugger.CheckExpression("(Function(val)(val+val))(1)", "Integer", "2");
+        }
+
+        [Fact]
+        public void EvaluateInvalidExpressions()
+        {
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+            VisualStudio.Debugger.CheckExpression("myNonsense", "", "error BC30451: 'myNonsense' is not declared. It may be inaccessible due to its protection level.");
+        }
+
+        [Fact]
+        public void StateMachineTypeParameters()
+        {
+            VisualStudio.Editor.SetText(@"
+Imports System
+Imports System.Collections.Generic
+
+Module Module1
+    Sub Main()
+        For Each arg In I({ ""a"", ""b""})
+            Console.WriteLine(arg)
+        Next
+    End Sub
+
+    Iterator Function I(Of T)(tt As T()) As IEnumerable(Of T)
+        For Each item In tt
+            Stop
+            Yield item
+        Next
+    End Function
+
+End Module
+");
+            VisualStudio.Debugger.Go(waitForBreakMode: true);
+            VisualStudio.LocalsWindow.Verify.CheckEntry( new string[] { "Type variables", "T" }, "String", "String");
+
+            // It is better to use the Immediate Window but DTE does not provide an access to it.
+            VisualStudio.Debugger.CheckExpression("GetType(T) = GetType(String)", "Boolean", "True");
+        }
+
+        public new void Dispose()
+        {
+            VisualStudio.Debugger.StepOver(waitForBreakOrEnd: true);
+            base.Dispose();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualStudioIntegrationTests.csproj b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualStudioIntegrationTests.csproj
index 0529e228bc986..6aa66ed26aa46 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/VisualStudioIntegrationTests.csproj
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/VisualStudioIntegrationTests.csproj
@@ -66,6 +66,7 @@
     <Compile Include="CSharp\CSharpAddMissingReference.cs" />
     <Compile Include="VisualBasic\BasicEditAndContinue.cs" />
     <Compile Include="VisualBasic\BasicEndConstruct.cs" />
+    <Compile Include="VisualBasic\BasicExpressionEvaluator.cs" />
     <Compile Include="VisualBasic\BasicReferenceHighlighting.cs" />
     <Compile Include="VisualBasic\BasicKeywordHighlighting.cs" />
     <Compile Include="VisualBasic\BasicEncapsulateField.cs" />
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/LocalsWindow_InProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/LocalsWindow_InProc.cs
index dc952b1ede9f5..c23a72096bdb6 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/LocalsWindow_InProc.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/LocalsWindow_InProc.cs
@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using EnvDTE80;
 
 namespace Microsoft.VisualStudio.IntegrationTest.Utilities.InProcess
@@ -9,22 +11,62 @@ internal class LocalsWindow_InProc : InProcComponent
     {
         public static LocalsWindow_InProc Create() => new LocalsWindow_InProc();
 
+        public int GetCount()
+        {
+            var dte = ((DTE2)GetDTE());
+            if (dte.Debugger.CurrentStackFrame != null) // Ensure that debugger is running
+            {
+                EnvDTE.Expressions locals = dte.Debugger.CurrentStackFrame.Locals;
+                return locals.Count;
+            }
+
+            return 0;
+        }
+
         public Common.Expression GetEntry(string entryName)
+        {
+            return new Common.Expression(GetEntryInternal(entryName));
+        }
+
+        public Common.Expression GetEntry(params string[] entryNames)
+        {
+            return new Common.Expression(GetEntryInternal(entryNames));
+        }
+
+        private EnvDTE.Expression GetEntryInternal(params string[] entryNames)
+        {
+            var entry = GetEntryInternal(entryNames[0]);
+            for (int i = 1; i < entryNames.Length; i++)
+            {
+                entry = GetEntryInternal(entryNames[i], entry.DataMembers);
+            }
+
+            return entry;
+        }
+
+        private EnvDTE.Expression GetEntryInternal(string entryName, EnvDTE.Expressions expressions)
+        {
+            var expressionCollection = expressions.Cast<EnvDTE.Expression>();
+            var expressionMatched = expressionCollection.FirstOrDefault(e => e.Name == entryName);
+            if (expressionMatched != null)
+            {
+                return expressionMatched;
+            }
+
+            string nestedExpressionNamesString = string.Join(",", expressionCollection.Select(e => e.Name));
+            throw new Exception($"Could not find the local named {entryName}. Available locals are {nestedExpressionNamesString}.");
+        }
+
+        private EnvDTE.Expression GetEntryInternal(string entryName)
         {
             var dte = ((DTE2)GetDTE());
             if (dte.Debugger.CurrentStackFrame != null) // Ensure that debugger is running
             {
                 EnvDTE.Expressions locals = dte.Debugger.CurrentStackFrame.Locals;
-                foreach (EnvDTE.Expression local in locals)
-                {
-                    if (local.Name == entryName)
-                    {
-                        return new Common.Expression(local);
-                    }
-                }
+                return GetEntryInternal(entryName, locals);
             }
 
-            throw new Exception($"Could not find the local named {entryName}.");
+            throw new Exception($"Could not find locals. Debugger is not running.");
         }
     }
 }
\ No newline at end of file
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/LocalsWindow_OutOfProc.Verifier.cs b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/LocalsWindow_OutOfProc.Verifier.cs
index 43b3512651eff..9919540d7a843 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/LocalsWindow_OutOfProc.Verifier.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/LocalsWindow_OutOfProc.Verifier.cs
@@ -21,6 +21,19 @@ public void CheckEntry(string entryName, string expectedType, string expectedVal
                 Assert.Equal(expectedType, entry.Type);
                 Assert.Equal(expectedValue, entry.Value);
             }
+
+            public void CheckEntry(string[] entryNames, string expectedType, string expectedValue)
+            {
+                var entry = _localsWindow._localsWindowInProc.GetEntry(entryNames);
+                Assert.Equal(expectedType, entry.Type);
+                Assert.Equal(expectedValue, entry.Value);
+            }
+
+            public void CheckCount(int expectedCount)
+            {
+                var actualCount = _localsWindow._localsWindowInProc.GetCount();
+                Assert.Equal(expectedCount, actualCount);
+            }
         }
     }
 }
\ No newline at end of file

From 4566936c8b056ed0313d99abf3d13616a34144e1 Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam.harwell@microsoft.com>
Date: Mon, 15 May 2017 16:21:37 -0500
Subject: [PATCH 256/284] Reduce GC overhead of memory mapped files

---
 ...iceFactory.CopiedMemoryMappedViewHandle.cs |  57 +++++++++
 ...yStorageServiceFactory.MemoryMappedInfo.cs | 117 ++++++------------
 .../Core/Desktop/Workspaces.Desktop.csproj    |   1 +
 3 files changed, 93 insertions(+), 82 deletions(-)
 create mode 100644 src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.CopiedMemoryMappedViewHandle.cs

diff --git a/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.CopiedMemoryMappedViewHandle.cs b/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.CopiedMemoryMappedViewHandle.cs
new file mode 100644
index 0000000000000..1a58af65643a3
--- /dev/null
+++ b/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.CopiedMemoryMappedViewHandle.cs
@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using Microsoft.Win32.SafeHandles;
+
+namespace Microsoft.CodeAnalysis.Host
+{
+    internal partial class TemporaryStorageServiceFactory
+    {
+        /// <summary>
+        /// This critical handle increments the reference count of a <see cref="SafeMemoryMappedViewHandle"/>. The view
+        /// will be released when it is disposed <em>and</em> all pointers acquired through
+        /// <see cref="SafeBuffer.AcquirePointer"/> (which this class uses) are released.
+        /// </summary>
+        /// <remarks>
+        /// <para><see cref="CriticalHandle"/> types are not reference counted, and are thus somewhat limited in their
+        /// usefulness. However, this handle class has tightly restricted accessibility and is only used by managed
+        /// code which does not rely on it counting references.</para>
+        /// </remarks>
+        private unsafe sealed class CopiedMemoryMappedViewHandle : CriticalHandleZeroOrMinusOneIsInvalid
+        {
+            private readonly SafeMemoryMappedViewHandle _viewHandle;
+
+            public CopiedMemoryMappedViewHandle(SafeMemoryMappedViewHandle viewHandle)
+            {
+                _viewHandle = viewHandle;
+
+                byte* pointer = null;
+
+                // The following code uses a constrained execution region (CER) to ensure that the code ends up in one
+                // of the following states, even in the presence of asynchronous exceptions like ThreadAbortException:
+                //
+                // 1. The pointer is not acquired, and the current handle is invalid (thus will not be released)
+                // 2. The pointer is acquired, and the current handle is fully initialized for later cleanup
+                RuntimeHelpers.PrepareConstrainedRegions();
+                try
+                {
+                    viewHandle.AcquirePointer(ref pointer);
+                }
+                finally
+                {
+                    SetHandle((IntPtr)pointer);
+                }
+            }
+
+            public byte* Pointer => (byte*)handle;
+
+            protected override bool ReleaseHandle()
+            {
+                _viewHandle.ReleasePointer();
+                return true;
+            }
+        }
+    }
+}
diff --git a/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.MemoryMappedInfo.cs b/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.MemoryMappedInfo.cs
index 7cacb0d4d2eeb..31ca84f651b6a 100644
--- a/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.MemoryMappedInfo.cs
+++ b/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.MemoryMappedInfo.cs
@@ -22,16 +22,27 @@ internal sealed class MemoryMappedInfo : IDisposable
         {
             private readonly string _name;
             private readonly long _size;
-            private readonly MemoryMappedFile _memoryMappedFile;
 
             /// <summary>
-            /// ref count of stream given out
+            /// The memory mapped file.
             /// </summary>
-            private int _streamCount;
+            /// <remarks>
+            /// <para>It is possible for this accessor to be disposed prior to the view and/or the streams which use it.
+            /// However, the operating system does not actually close the views which are in use until the view handles
+            /// are closed as well, even if the <see cref="MemoryMappedFile"/> is disposed first.</para>
+            /// </remarks>
+            private readonly MemoryMappedFile _memoryMappedFile;
 
             /// <summary>
             /// actual memory accessor that owns the VM
             /// </summary>
+            /// <remarks>
+            /// <para>It is possible for this accessor to be disposed prior to the streams which use it. However, the
+            /// streams interact directly with the underlying memory buffer, and keep a
+            /// <see cref="CopiedMemoryMappedViewHandle"/> to prevent that buffer from being released while still in
+            /// use. The <see cref="SafeHandle"/> used by this accessor is reference counted, and is not finally
+            /// released until the reference count reaches zero.</para>
+            /// </remarks>
             private MemoryMappedViewAccessor _accessor;
 
             public MemoryMappedInfo(long size)
@@ -40,9 +51,6 @@ public MemoryMappedInfo(long size)
                 _size = size;
 
                 _memoryMappedFile = MemoryMappedFile.CreateNew(_name, size);
-
-                _streamCount = 0;
-                _accessor = null;
             }
 
             public MemoryMappedInfo(string name, long size)
@@ -51,9 +59,6 @@ public MemoryMappedInfo(string name, long size)
                 _size = size;
 
                 _memoryMappedFile = MemoryMappedFile.OpenExisting(_name);
-
-                _streamCount = 0;
-                _accessor = null;
             }
 
             /// <summary>
@@ -81,7 +86,7 @@ public Stream CreateReadableStream()
                 // CreateViewStream is not guaranteed to be thread-safe
                 lock (_memoryMappedFile)
                 {
-                    if (_streamCount == 0)
+                    if (_accessor == null)
                     {
                         try
                         {
@@ -97,8 +102,8 @@ public Stream CreateReadableStream()
                         }
                     }
 
-                    _streamCount++;
-                    return new SharedReadableStream(this, _accessor, _size);
+                    Contract.Assert(_accessor.CanRead);
+                    return new SharedReadableStream(this, new CopiedMemoryMappedViewHandle(_accessor.SafeMemoryMappedViewHandle), _accessor.PointerOffset, _size);
                 }
             }
 
@@ -115,24 +120,6 @@ public Stream CreateWritableStream()
                 }
             }
 
-            private void StreamDisposed()
-            {
-                lock (_memoryMappedFile)
-                {
-                    _streamCount--;
-                    if (_streamCount == 0 && _accessor != null)
-                    {
-                        _accessor.Dispose();
-                        _accessor = null;
-                    }
-                }
-            }
-
-            ~MemoryMappedInfo()
-            {
-                Dispose(false);
-            }
-
             public void Dispose()
             {
                 Dispose(true);
@@ -141,25 +128,21 @@ public void Dispose()
 
             private void Dispose(bool disposing)
             {
-                lock (_memoryMappedFile)
+                if (disposing)
                 {
-                    if (_accessor != null)
+                    lock (_memoryMappedFile)
                     {
-                        // dispose accessor it owns.
-                        // if someone explicitly called Dispose when streams given out are not
-                        // disposed yet, the accessor each stream has will simply stop working.
-                        //
-                        // it is caller's responsibility to make sure all streams it got from
-                        // the temporary storage are disposed before calling dispose on the storage.
-                        //
-                        // otherwise, finalizer will take care of disposing stuff as we used to be.
-                        _accessor.Dispose();
-                        _accessor = null;
+                        if (_accessor != null)
+                        {
+                            // (see remarks on accessor for relation between _accessor and the streams)
+                            _accessor.Dispose();
+                            _accessor = null;
+                        }
                     }
-                }
 
-                // Dispose the memoryMappedFile
-                _memoryMappedFile.Dispose();
+                    // (see remarks on accessor for relation between _memoryMappedFile and the views/streams)
+                    _memoryMappedFile.Dispose();
+                }
             }
 
             public static string CreateUniqueName(long size)
@@ -169,31 +152,19 @@ public static string CreateUniqueName(long size)
 
             private unsafe sealed class SharedReadableStream : Stream, ISupportDirectMemoryAccess
             {
-                private readonly MemoryMappedViewAccessor _accessor;
+                private readonly CopiedMemoryMappedViewHandle _handle;
 
-                private MemoryMappedInfo _owner;
                 private byte* _start;
                 private byte* _current;
                 private readonly byte* _end;
 
-                public SharedReadableStream(MemoryMappedInfo owner, MemoryMappedViewAccessor accessor, long length)
+                public SharedReadableStream(MemoryMappedInfo owner, CopiedMemoryMappedViewHandle handle, long offset, long length)
                 {
-                    Contract.Assert(accessor.CanRead);
-
-                    _owner = owner;
-                    _accessor = accessor;
-                    _current = _start = AcquirePointer(accessor);
+                    _handle = handle;
+                    _current = _start = handle.Pointer + offset;
                     _end = checked(_start + length);
                 }
 
-                ~SharedReadableStream()
-                {
-                    // we don't have control on stream we give out to others such as
-                    // compiler (ImageOnlyMetadataReference), make sure we dispose resource 
-                    // at the end if Disposed is not called explicitly.
-                    Dispose(false);
-                }
-
                 public override bool CanRead
                 {
                     get
@@ -326,17 +297,12 @@ protected override void Dispose(bool disposing)
                 {
                     base.Dispose(disposing);
 
-                    if (_start != null)
+                    if (disposing)
                     {
-                        _accessor.SafeMemoryMappedViewHandle.ReleasePointer();
-                        _start = null;
+                        _handle.Dispose();
                     }
 
-                    if (_owner != null)
-                    {
-                        _owner.StreamDisposed();
-                        _owner = null;
-                    }
+                    _start = null;
                 }
 
                 /// <summary>
@@ -346,19 +312,6 @@ public IntPtr GetPointer()
                 {
                     return (IntPtr)_start;
                 }
-
-                /// <summary>
-                /// Acquire the fixed pointer to the start of the memory mapped view.
-                /// The pointer will be released during <see cref="Dispose(bool)"/>
-                /// </summary>
-                /// <returns>The pointer to the start of the memory mapped view. The pointer is valid, and remains fixed for the lifetime of this object.</returns>
-                private static byte* AcquirePointer(MemoryMappedViewAccessor accessor)
-                {
-                    byte* ptr = null;
-                    accessor.SafeMemoryMappedViewHandle.AcquirePointer(ref ptr);
-                    ptr += accessor.PointerOffset;
-                    return ptr;
-                }
             }
         }
     }
diff --git a/src/Workspaces/Core/Desktop/Workspaces.Desktop.csproj b/src/Workspaces/Core/Desktop/Workspaces.Desktop.csproj
index ac315231d59e0..ef6502385fe8f 100644
--- a/src/Workspaces/Core/Desktop/Workspaces.Desktop.csproj
+++ b/src/Workspaces/Core/Desktop/Workspaces.Desktop.csproj
@@ -95,6 +95,7 @@
     <Compile Include="Workspace\Host\Mef\DesktopMefHostServices.cs" />
     <Compile Include="Workspace\Host\Mef\MefV1HostServices.cs" />
     <Compile Include="Workspace\Host\SimpleAnalyzerAssemblyLoaderService.cs" />
+    <Compile Include="Workspace\Host\TemporaryStorage\TemporaryStorageServiceFactory.CopiedMemoryMappedViewHandle.cs" />
     <Compile Include="Workspace\Host\TemporaryStorage\TemporaryStorageServiceFactory.cs" />
     <Compile Include="Workspace\Host\TemporaryStorage\TemporaryStorageServiceFactory.MemoryMappedInfo.cs" />
     <Compile Include="Workspace\Host\TextFactory\DesktopTextFactoryService.cs" />

From 73aad3f216da807589fd9ead4ce124061c481bbf Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam.harwell@microsoft.com>
Date: Mon, 15 May 2017 19:59:53 -0500
Subject: [PATCH 257/284] Avoid releasing memory mapped file handles during
 shutdown

Fixes #19493
---
 ...yStorageServiceFactory.CopiedMemoryMappedViewHandle.cs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.CopiedMemoryMappedViewHandle.cs b/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.CopiedMemoryMappedViewHandle.cs
index 1a58af65643a3..2f0339cecaf68 100644
--- a/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.CopiedMemoryMappedViewHandle.cs
+++ b/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.CopiedMemoryMappedViewHandle.cs
@@ -49,7 +49,13 @@ public CopiedMemoryMappedViewHandle(SafeMemoryMappedViewHandle viewHandle)
 
             protected override bool ReleaseHandle()
             {
-                _viewHandle.ReleasePointer();
+                // The operating system will release these handles when the process terminates, so do not spend time
+                // releasing them manually in that case. Doing so causes unnecessary delays during application shutdown.
+                if (!Environment.HasShutdownStarted)
+                {
+                    _viewHandle.ReleasePointer();
+                }
+
                 return true;
             }
         }

From 4a09b953259ec1a48c6ca72efbf4f8b71382d658 Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam.harwell@microsoft.com>
Date: Tue, 16 May 2017 16:19:05 -0500
Subject: [PATCH 258/284] Additional use and development comments for
 MemoryMappedInfo

---
 ...geServiceFactory.CopiedMemoryMappedViewHandle.cs |  3 +++
 ...mporaryStorageServiceFactory.MemoryMappedInfo.cs | 13 +++++++++++++
 2 files changed, 16 insertions(+)

diff --git a/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.CopiedMemoryMappedViewHandle.cs b/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.CopiedMemoryMappedViewHandle.cs
index 2f0339cecaf68..a3e25689e1886 100644
--- a/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.CopiedMemoryMappedViewHandle.cs
+++ b/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.CopiedMemoryMappedViewHandle.cs
@@ -18,6 +18,9 @@ internal partial class TemporaryStorageServiceFactory
         /// <para><see cref="CriticalHandle"/> types are not reference counted, and are thus somewhat limited in their
         /// usefulness. However, this handle class has tightly restricted accessibility and is only used by managed
         /// code which does not rely on it counting references.</para>
+        ///
+        /// <para>This is a supporting class for <see cref="MemoryMappedInfo"/>. See additional comments on that
+        /// class.</para>
         /// </remarks>
         private unsafe sealed class CopiedMemoryMappedViewHandle : CriticalHandleZeroOrMinusOneIsInvalid
         {
diff --git a/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.MemoryMappedInfo.cs b/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.MemoryMappedInfo.cs
index 31ca84f651b6a..95275cd89e922 100644
--- a/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.MemoryMappedInfo.cs
+++ b/src/Workspaces/Core/Desktop/Workspace/Host/TemporaryStorage/TemporaryStorageServiceFactory.MemoryMappedInfo.cs
@@ -18,6 +18,19 @@ internal partial class TemporaryStorageServiceFactory
         /// most of our view will have short lifetime, but there are cases where view might live a bit longer such as
         /// metadata dll shadow copy. shared view will help those cases.
         /// </summary>
+        /// <remarks>
+        /// <para>Instances of this class should be disposed when they are no longer needed. After disposing this
+        /// instance, it should no longer be used. However, streams obtained through <see cref="CreateReadableStream"/>
+        /// or <see cref="CreateWritableStream"/> will not be invalidated until they are disposed independently (which
+        /// may occur before or after the <see cref="MemoryMappedInfo"/> is disposed.</para>
+        ///
+        /// <para>This class and its nested types have familiar APIs and predictable behavior when used in other code,
+        /// but are non-trivial to work on. The implementations of <see cref="IDisposable"/> adhere to the best
+        /// practices described in
+        /// <see href="http://joeduffyblog.com/2005/04/08/dg-update-dispose-finalization-and-resource-management/">DG
+        /// Update: Dispose, Finalization, and Resource Management</see>. Additional notes regarding operating system
+        /// behavior leveraged for efficiency are given in comments.</para>
+        /// </remarks>
         internal sealed class MemoryMappedInfo : IDisposable
         {
             private readonly string _name;

From babc76b2a167af94df47c32035b129b78b4451e8 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 16 May 2017 14:35:07 -0700
Subject: [PATCH 259/284] Try out another way to block.

---
 .../Core/FindUsages/IDefinitionsAndReferencesFactory.cs        | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/Core/FindUsages/IDefinitionsAndReferencesFactory.cs b/src/EditorFeatures/Core/FindUsages/IDefinitionsAndReferencesFactory.cs
index 396595d0383bc..5fad7c44012ef 100644
--- a/src/EditorFeatures/Core/FindUsages/IDefinitionsAndReferencesFactory.cs
+++ b/src/EditorFeatures/Core/FindUsages/IDefinitionsAndReferencesFactory.cs
@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.FindUsages
 {
@@ -47,7 +48,7 @@ public static DefinitionItem ToNonClassifiedDefinitionItem(
             // to compute the classified spans for the locations of the definition.  So it's totally 
             // fine to pass in CancellationToken.None and block on the result.
             return ToDefinitionItemAsync(definition, solution, includeHiddenLocations,
-                includeClassifiedSpans: false, cancellationToken: CancellationToken.None).Result;
+                includeClassifiedSpans: false, cancellationToken: CancellationToken.None).WaitAndGetResult_CanCallOnBackground(CancellationToken.None);
         }
 
         public static Task<DefinitionItem> ToClassifiedDefinitionItemAsync(

From 936ae889435445b1261465a5e0232a0c96a8a1b5 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 16 May 2017 14:43:56 -0700
Subject: [PATCH 260/284] Address null ref.

---
 .../Core/FindUsages/ClassifiedSpansAndHighlightSpan.cs         | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/Core/FindUsages/ClassifiedSpansAndHighlightSpan.cs b/src/EditorFeatures/Core/FindUsages/ClassifiedSpansAndHighlightSpan.cs
index edd23bbcc8f1e..dd18a257de09d 100644
--- a/src/EditorFeatures/Core/FindUsages/ClassifiedSpansAndHighlightSpan.cs
+++ b/src/EditorFeatures/Core/FindUsages/ClassifiedSpansAndHighlightSpan.cs
@@ -43,7 +43,8 @@ public static async Task<ClassifiedSpansAndHighlightSpan> ClassifyAsync(
             // If the document span is providing us with the classified spans up front, then we
             // can just use that.  Otherwise, go back and actually classify the text for the line
             // the document span is on.
-            if (documentSpan.Properties.TryGetValue(Key, out var value))
+            if (documentSpan.Properties != null &&
+                documentSpan.Properties.TryGetValue(Key, out var value))
             {
                 return (ClassifiedSpansAndHighlightSpan)value;
             }

From d2a804204e1b084a57ce511363ca7a655af808ea Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 16 May 2017 18:14:49 -0700
Subject: [PATCH 261/284] Restore old APi to make migration easier.

---
 src/EditorFeatures/Core/EditorFeatures.csproj |  1 +
 .../IDocumentHighlightsService.cs             | 53 ++++++++++++
 ...ReferenceHighlightingViewTaggerProvider.cs | 80 +++++++++++++++----
 3 files changed, 119 insertions(+), 15 deletions(-)
 create mode 100644 src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs

diff --git a/src/EditorFeatures/Core/EditorFeatures.csproj b/src/EditorFeatures/Core/EditorFeatures.csproj
index 000857eca1df7..9edc6adfec509 100644
--- a/src/EditorFeatures/Core/EditorFeatures.csproj
+++ b/src/EditorFeatures/Core/EditorFeatures.csproj
@@ -165,6 +165,7 @@
     <Compile Include="Implementation\Intellisense\QuickInfo\Providers\LinkedFileDiscrepancyException.cs" />
     <Compile Include="Implementation\Intellisense\Completion\CompletionFilterReason.cs" />
     <Compile Include="Implementation\Intellisense\Completion\FilterResult.cs" />
+    <Compile Include="Implementation\ReferenceHighlighting\IDocumentHighlightsService.cs" />
     <Compile Include="Implementation\Structure\BlockTagState.cs" />
     <Compile Include="Implementation\Suggestions\ISuggestedActionCallback.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionSetComparer.cs" />
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs
new file mode 100644
index 0000000000000..c36aaed9954cd
--- /dev/null
+++ b/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs
@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.Editor
+{
+    internal enum HighlightSpanKind
+    {
+        None,
+        Definition,
+        Reference,
+        WrittenReference,
+    }
+
+    internal struct HighlightSpan
+    {
+        public TextSpan TextSpan { get; }
+        public HighlightSpanKind Kind { get; }
+
+        public HighlightSpan(TextSpan textSpan, HighlightSpanKind kind) : this()
+        {
+            this.TextSpan = textSpan;
+            this.Kind = kind;
+        }
+    }
+
+    internal struct DocumentHighlights
+    {
+        public Document Document { get; }
+        public ImmutableArray<HighlightSpan> HighlightSpans { get; }
+
+        public DocumentHighlights(Document document, ImmutableArray<HighlightSpan> highlightSpans)
+        {
+            this.Document = document;
+            this.HighlightSpans = highlightSpans;
+        }
+    }
+
+    /// <summary>
+    /// Note: kept around for back compat until F# and TypeScript move over to 
+    /// <see cref="Microsoft.CodeAnalysis.DocumentHighlighting.IDocumentHighlightsService"/>.
+    /// </summary>
+    internal interface IDocumentHighlightsService : ILanguageService
+    {
+        Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsAsync(
+            Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken);
+    }
+}
\ No newline at end of file
diff --git a/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs b/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
index e2367ad5f5d3d..94ab3331cb668 100644
--- a/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
@@ -5,14 +5,17 @@
 using System.Collections.Immutable;
 using System.ComponentModel.Composition;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 using Microsoft.CodeAnalysis.Editor.Tagging;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Notification;
 using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
@@ -111,13 +114,12 @@ protected override Task ProduceTagsAsync(TaggerContext<NavigableHighlightTag> co
             }
 
             // Otherwise, we need to go produce all tags.
-            return ProduceTagsAsync(context, caretPosition, workspace, document);
+            return ProduceTagsAsync(context, caretPosition, document);
         }
 
         internal async Task ProduceTagsAsync(
             TaggerContext<NavigableHighlightTag> context,
             SnapshotPoint position,
-            Workspace workspace,
             Document document)
         {
             var cancellationToken = context.CancellationToken;
@@ -128,25 +130,73 @@ internal async Task ProduceTagsAsync(
             {
                 if (document != null)
                 {
-                    var documentHighlightsService = document.Project.LanguageServices.GetService<IDocumentHighlightsService>();
-                    if (documentHighlightsService != null)
+                    // As we transition to the new API (defined at the Features layer) we support
+                    // calling into both it and the old API (defined at the EditorFeatures layer).
+                    //
+                    // Once TypeScript and F# can move over, then we can remove the calls to the old
+                    // API.
+                    await TryNewServiceAsync(context, position, document).ConfigureAwait(false);
+                    await TryOldServiceAsync(context, position, document).ConfigureAwait(false);
+                }
+            }
+        }
+
+        private Task TryOldServiceAsync(TaggerContext<NavigableHighlightTag> context, SnapshotPoint position, Document document)
+        {
+            return TryServiceAsync<IDocumentHighlightsService>(
+                context, position, document, 
+                (s, d, p, ds, c) => s.GetDocumentHighlightsAsync(d, p, ds, c));
+        }
+
+        private Task TryNewServiceAsync(
+            TaggerContext<NavigableHighlightTag> context, SnapshotPoint position, Document document)
+        {
+            return TryServiceAsync<DocumentHighlighting.IDocumentHighlightsService>(
+                context, position, document,
+                async (service, doc, point, documents, cancellation) =>
+                {
+                    // Call into the new service.
+                    var newHighlights = await service.GetDocumentHighlightsAsync(doc, point, documents, cancellation).ConfigureAwait(false);
+
+                    // then convert the result to the form the old service would return.
+                    return ConvertHighlights(newHighlights);
+                });
+        }
+
+        private async Task TryServiceAsync<T>(
+            TaggerContext<NavigableHighlightTag> context, SnapshotPoint position, Document document,
+            Func<T, Document, SnapshotPoint, ImmutableHashSet<Document>, CancellationToken, Task<ImmutableArray<DocumentHighlights>>> getDocumentHighlightsAsync)
+            where T : class, ILanguageService
+        {
+            var cancellationToken = context.CancellationToken;
+            var documentHighlightsService = document.GetLanguageService<T>();
+            if (documentHighlightsService != null)
+            {
+                // We only want to search inside documents that correspond to the snapshots
+                // we're looking at
+                var documentsToSearch = ImmutableHashSet.CreateRange(context.SpansToTag.Select(vt => vt.Document).WhereNotNull());
+                var documentHighlightsList = await getDocumentHighlightsAsync(
+                    documentHighlightsService, document, position, documentsToSearch, cancellationToken).ConfigureAwait(false);
+                if (documentHighlightsList != null)
+                {
+                    foreach (var documentHighlights in documentHighlightsList)
                     {
-                        // We only want to search inside documents that correspond to the snapshots
-                        // we're looking at
-                        var documentsToSearch = ImmutableHashSet.CreateRange(context.SpansToTag.Select(vt => vt.Document).WhereNotNull());
-                        var documentHighlightsList = await documentHighlightsService.GetDocumentHighlightsAsync(document, position, documentsToSearch, cancellationToken).ConfigureAwait(false);
-                        if (documentHighlightsList != null)
-                        {
-                            foreach (var documentHighlights in documentHighlightsList)
-                            {
-                                await AddTagSpansAsync(context, solution, documentHighlights).ConfigureAwait(false);
-                            }
-                        }
+                        await AddTagSpansAsync(
+                            context, document.Project.Solution, documentHighlights).ConfigureAwait(false);
                     }
                 }
             }
         }
 
+        private ImmutableArray<DocumentHighlights> ConvertHighlights(ImmutableArray<DocumentHighlighting.DocumentHighlights> newHighlights)
+            => newHighlights.SelectAsArray(
+                documentHighlights => new DocumentHighlights(
+                    documentHighlights.Document,
+                    documentHighlights.HighlightSpans.SelectAsArray(
+                        highlightSpan => new HighlightSpan(
+                            highlightSpan.TextSpan,
+                            (HighlightSpanKind)highlightSpan.Kind))));
+
         private async Task AddTagSpansAsync(
             TaggerContext<NavigableHighlightTag> context,
             Solution solution,

From b7b663857c2a071e5287fd9c74b2f2b42225d280 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 16 May 2017 18:17:59 -0700
Subject: [PATCH 262/284] Move file.

---
 src/EditorFeatures/Core/EditorFeatures.csproj                   | 2 +-
 .../ReferenceHighlighting/IDocumentHighlightsService.cs         | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/EditorFeatures/Core/{Implementation => }/ReferenceHighlighting/IDocumentHighlightsService.cs (100%)

diff --git a/src/EditorFeatures/Core/EditorFeatures.csproj b/src/EditorFeatures/Core/EditorFeatures.csproj
index 9edc6adfec509..f794046716f55 100644
--- a/src/EditorFeatures/Core/EditorFeatures.csproj
+++ b/src/EditorFeatures/Core/EditorFeatures.csproj
@@ -165,7 +165,7 @@
     <Compile Include="Implementation\Intellisense\QuickInfo\Providers\LinkedFileDiscrepancyException.cs" />
     <Compile Include="Implementation\Intellisense\Completion\CompletionFilterReason.cs" />
     <Compile Include="Implementation\Intellisense\Completion\FilterResult.cs" />
-    <Compile Include="Implementation\ReferenceHighlighting\IDocumentHighlightsService.cs" />
+    <Compile Include="ReferenceHighlighting\IDocumentHighlightsService.cs" />
     <Compile Include="Implementation\Structure\BlockTagState.cs" />
     <Compile Include="Implementation\Suggestions\ISuggestedActionCallback.cs" />
     <Compile Include="Implementation\Suggestions\SuggestedActionSetComparer.cs" />
diff --git a/src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs b/src/EditorFeatures/Core/ReferenceHighlighting/IDocumentHighlightsService.cs
similarity index 100%
rename from src/EditorFeatures/Core/Implementation/ReferenceHighlighting/IDocumentHighlightsService.cs
rename to src/EditorFeatures/Core/ReferenceHighlighting/IDocumentHighlightsService.cs

From 22e68c4d74652f25654d2650b4965c8470022950 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 16 May 2017 18:21:03 -0700
Subject: [PATCH 263/284] Improve diff.

---
 .../IDocumentHighlightsService.cs             | 84 ++++++++++---------
 1 file changed, 44 insertions(+), 40 deletions(-)

diff --git a/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs b/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
index 0e08d4418c4f5..b20fbedf8bb1d 100644
--- a/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
+++ b/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
@@ -6,43 +6,47 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Text;
 
-namespace Microsoft.CodeAnalysis.DocumentHighlighting
-{
-    internal enum HighlightSpanKind
-    {
-        None,
-        Definition,
-        Reference,
-        WrittenReference,
-    }
-
-    internal struct HighlightSpan
-    {
-        public TextSpan TextSpan { get; }
-        public HighlightSpanKind Kind { get; }
-
-        public HighlightSpan(TextSpan textSpan, HighlightSpanKind kind) : this()
-        {
-            this.TextSpan = textSpan;
-            this.Kind = kind;
-        }
-    }
-
-    internal struct DocumentHighlights
-    {
-        public Document Document { get; }
-        public ImmutableArray<HighlightSpan> HighlightSpans { get; }
-
-        public DocumentHighlights(Document document, ImmutableArray<HighlightSpan> highlightSpans)
-        {
-            this.Document = document;
-            this.HighlightSpans = highlightSpans;
-        }
-    }
-
-    internal interface IDocumentHighlightsService : ILanguageService
-    {
-        Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsAsync(
-            Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken);
-    }
-}
+ namespace Microsoft.CodeAnalysis.DocumentHighlighting
+ {
+     internal enum HighlightSpanKind
+     {
+         None,
+         Definition,
+         Reference,
+         WrittenReference,
+     }
+ 
+     internal struct HighlightSpan
+     {
+         public TextSpan TextSpan { get; }
+         public HighlightSpanKind Kind { get; }
+ 
+         public HighlightSpan(TextSpan textSpan, HighlightSpanKind kind) : this()
+         {
+             this.TextSpan = textSpan;
+             this.Kind = kind;
+         }
+     }
+ 
+     internal struct DocumentHighlights
+     {
+         public Document Document { get; }
+         public ImmutableArray<HighlightSpan> HighlightSpans { get; }
+ 
+         public DocumentHighlights(Document document, ImmutableArray<HighlightSpan> highlightSpans)
+         {
+             this.Document = document;
+             this.HighlightSpans = highlightSpans;
+         }
+     }
+ 
+     /// <summary>
+     /// Note: This is the new version of the language service and superceded the same named type
+     /// in the EditorFeatures layer.
+     /// </summary>
+     internal interface IDocumentHighlightsService : ILanguageService
+     {
+         Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsAsync(
+             Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken);
+     }
+ }
\ No newline at end of file

From ebaaf9546aaa1aace3863b115004db7e02431f70 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Tue, 16 May 2017 18:22:07 -0700
Subject: [PATCH 264/284] Improve diff.

---
 .../DocumentHighlighting/IDocumentHighlightsService.cs      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs b/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
index b20fbedf8bb1d..52ec389940a5a 100644
--- a/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
+++ b/src/Features/Core/Portable/DocumentHighlighting/IDocumentHighlightsService.cs
@@ -6,8 +6,8 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Text;
 
- namespace Microsoft.CodeAnalysis.DocumentHighlighting
- {
+namespace Microsoft.CodeAnalysis.DocumentHighlighting
+{
      internal enum HighlightSpanKind
      {
          None,
@@ -49,4 +49,4 @@ internal interface IDocumentHighlightsService : ILanguageService
          Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsAsync(
              Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken);
      }
- }
\ No newline at end of file
+}
\ No newline at end of file

From 3361cb03e2561e469b694407c905f47cbb45ad07 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Wed, 17 May 2017 00:59:59 -0700
Subject: [PATCH 265/284] Address review comments

---
 .../CSharp/Portable/BoundTree/Expression.cs   |   5 +-
 .../LocalRewriter/LocalRewriter_Call.cs       |  59 ++--
 .../LocalRewriter/LocalRewriter_Conversion.cs |   2 +-
 .../IOperation/IOperationTests_IArgument.cs   | 293 +++++++++++++++---
 .../Utilities/CSharp/SemanticModelTestBase.cs |  49 ++-
 5 files changed, 326 insertions(+), 82 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index 6922c87042c73..8d2dbbadb61c0 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -215,7 +215,10 @@ ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder
         {
             get
             {
-                MethodSymbol accessor = this.IsLeftOfAssignment ? this.Indexer.SetMethod : this.Indexer.GetMethod; 
+                MethodSymbol accessor = this.IsLeftOfAssignment && !this.Indexer.ReturnsByRef 
+                    ? this.Indexer.GetOwnOrInheritedSetMethod() 
+                    : this.Indexer.GetOwnOrInheritedGetMethod(); 
+
                 return BoundCall.DeriveArguments(this, 
                     this.BinderOpt, 
                     this.Indexer, 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index 2867d1824080c..c1b023b0f0d66 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -543,7 +543,8 @@ internal static ImmutableArray<IArgument> MakeArgumentsInEvaluationOrder(
                 argumentsInEvaluationBuilder, 
                 missingParametersBuilder);
 
-            AppendMissingOptionalArguments(syntax, optionalParametersMethod, expanded, binder, missingParametersBuilder.ToImmutableAndFree(), argumentsInEvaluationBuilder);
+            AppendMissingOptionalArguments(syntax, methodOrIndexer, optionalParametersMethod, expanded, binder, missingParametersBuilder, argumentsInEvaluationBuilder);
+            missingParametersBuilder.Free();
 
             return argumentsInEvaluationBuilder.ToImmutableAndFree();
         }
@@ -681,7 +682,7 @@ private static void BuildExplicitArgumentsInEvaluationOrder(
             /* out */ ArrayBuilder<ParameterSymbol> missingParametersBuilder)
         {
             ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters();
-            ArrayBuilder<int> processedParameters = ArrayBuilder<int>.GetInstance(parameters.Length);
+            PooledHashSet<int> processedParameters = PooledHashSet<int>.GetInstance();
 
             for (int a = 0; a < arguments.Length; ++a)
             {
@@ -986,13 +987,15 @@ private void InsertMissingOptionalArguments(SyntaxNode syntax,
             }
         }
 
-        private static void AppendMissingOptionalArguments(SyntaxNode syntax,  
+        private static void AppendMissingOptionalArguments(SyntaxNode syntax, 
+            Symbol methodOrIndexer,
             MethodSymbol optionalParametersMethod,
             bool expanded, 
             Binder binder,
-            ImmutableArray<ParameterSymbol> missingParameters,
+            ArrayBuilder<ParameterSymbol> missingParameters,
             ArrayBuilder<IArgument> argumentsBuilder)
         {
+            ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters();
             ImmutableArray<ParameterSymbol> parametersOfOptionalParametersMethod = optionalParametersMethod.Parameters; 
 
             foreach (ParameterSymbol parameter in missingParameters)
@@ -1001,11 +1004,11 @@ private static void AppendMissingOptionalArguments(SyntaxNode syntax,
                 ArgumentKind kind;
 
                 // In case of indexer access, missing parameters are corresponding to the indexer symbol, we need to 
-                // get default values base on actual accessor method parameter symbols (but still want to tie resulted IArgument 
+                // get default values based on actual accessor method parameter symbols (but still want to tie resulted IArgument 
                 // to the indexer parameter.)
                 ParameterSymbol parameterOfOptionalParametersMethod = parametersOfOptionalParametersMethod[parameter.Ordinal];
 
-                if (expanded && parameterOfOptionalParametersMethod.Ordinal == parametersOfOptionalParametersMethod.Length - 1)
+                if (expanded && parameterOfOptionalParametersMethod.Ordinal == parameters.Length - 1)
                 {
                     Debug.Assert(parameterOfOptionalParametersMethod.IsParams);
 
@@ -1157,9 +1160,7 @@ private static BoundExpression GetDefaultParameterValue(
                 if (parameterType.IsNullableType())
                 {
                     TypeSymbol nullableType = parameterType.GetNullableUnderlyingType();
-                    defaultValue = isLowering
-                        ? localRewriter.MakeConversionNode(lineLiteral, nullableType, false)                
-                        : MakeConversionForIOperation(lineLiteral, nullableType, syntax, compilation, diagnostics, false); 
+                    defaultValue = MakeConversionNode(lineLiteral, nullableType, @checked: false);
 
                     // wrap it in a nullable ctor.
                     defaultValue = new BoundObjectCreationExpression(
@@ -1169,19 +1170,15 @@ private static BoundExpression GetDefaultParameterValue(
                         defaultValue);
                 }
                 else
-                {                                                                                                                                     
-                    defaultValue = isLowering
-                        ? localRewriter.MakeConversionNode(lineLiteral, parameterType, false)
-                        : MakeConversionForIOperation(lineLiteral, parameterType, syntax, compilation, diagnostics, false);
+                {
+                    defaultValue = MakeConversionNode(lineLiteral, parameterType, @checked: false);
                 }  
             }
             else if (parameter.IsCallerFilePath && ((callerSourceLocation = GetCallerLocation(syntax, enableCallerInfo)) != null))
             {
                 string path = callerSourceLocation.SourceTree.GetDisplayPath(callerSourceLocation.SourceSpan, compilation.Options.SourceReferenceResolver);
-                BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(path), compilation.GetSpecialType(SpecialType.System_String), localRewriter); 
-                defaultValue = isLowering
-                    ? localRewriter.MakeConversionNode(memberNameLiteral, parameterType, false)
-                    : MakeConversionForIOperation(memberNameLiteral, parameterType, syntax, compilation, diagnostics, false);
+                BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(path), compilation.GetSpecialType(SpecialType.System_String), localRewriter);
+                defaultValue = MakeConversionNode(memberNameLiteral, parameterType, @checked: false);
             }
             else if (parameter.IsCallerMemberName && ((callerSourceLocation = GetCallerLocation(syntax, enableCallerInfo)) != null))
             {
@@ -1246,10 +1243,8 @@ private static BoundExpression GetDefaultParameterValue(
                     memberName = binder.ContainingMember().GetMemberCallerName(); 
                 }
 
-                BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(memberName), compilation.GetSpecialType(SpecialType.System_String), localRewriter);  
-                defaultValue = isLowering
-                    ? localRewriter.MakeConversionNode(memberNameLiteral, parameterType, false)
-                    : MakeConversionForIOperation(memberNameLiteral, parameterType, syntax, compilation, diagnostics, false);
+                BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(memberName), compilation.GetSpecialType(SpecialType.System_String), localRewriter);
+                defaultValue = MakeConversionNode(memberNameLiteral, parameterType, @checked: false);
             }
             else if (defaultConstantValue == ConstantValue.NotAvailable)
             {                                                                                 
@@ -1284,9 +1279,7 @@ private static BoundExpression GetDefaultParameterValue(
                 // The parameter's underlying type might not match the constant type. For example, we might have
                 // a default value of 5 (an integer) but a parameter type of decimal?.
 
-                defaultValue = isLowering
-                    ? localRewriter.MakeConversionNode(defaultValue, parameterType.GetNullableUnderlyingType(), @checked: false, acceptFailingConversion: true)
-                    : MakeConversionForIOperation(defaultValue, parameterType.GetNullableUnderlyingType(), syntax, compilation, diagnostics, @checked: false, acceptFailingConversion: true);
+                defaultValue = MakeConversionNode(defaultValue, parameterType.GetNullableUnderlyingType(), @checked: false, acceptFailingConversion: true);
 
                 // Finally, wrap it in a nullable ctor.
                 defaultValue = new BoundObjectCreationExpression(
@@ -1306,13 +1299,23 @@ private static BoundExpression GetDefaultParameterValue(
                 TypeSymbol constantType = compilation.GetSpecialType(defaultConstantValue.SpecialType);
                 defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType, localRewriter);
                 // The parameter type might not match the constant type.                                                                                                                    
-                defaultValue = isLowering
-                    ? localRewriter.MakeConversionNode(defaultValue, parameterType, @checked: false, acceptFailingConversion: true)
-                    : MakeConversionForIOperation(defaultValue, parameterType, syntax, compilation, diagnostics, @checked: false, acceptFailingConversion: true);
+                defaultValue = MakeConversionNode(defaultValue, parameterType, @checked: false, acceptFailingConversion: true);
             }
 
             return defaultValue;
-        }
+
+            BoundExpression MakeConversionNode(BoundExpression operand, TypeSymbol type, bool @checked, bool acceptFailingConversion = false)
+            {
+                if (isLowering)
+                {                                         
+                    return localRewriter.MakeConversionNode(operand, type, @checked, acceptFailingConversion);
+                }
+                else
+                {                                                                                  
+                    return MakeConversionForIOperation(operand, type, syntax, compilation, diagnostics, @checked, acceptFailingConversion);
+                }
+            }
+        }   
 
         private BoundExpression GetDefaultParameterSpecial(SyntaxNode syntax, ParameterSymbol parameter)
         {
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
index 3e76aadb3133c..633189e6c6302 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
@@ -506,7 +506,7 @@ private static BoundExpression MakeConversionForIOperation(
         {
             Conversion conversion = MakeConversion(operand, type, compilation, diagnostics, acceptFailingConversion);
 
-            if (conversion.Kind == ConversionKind.Identity)
+            if (conversion.IsIdentity)
             {
                 return operand;
             }
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index 1615cbe88cb81..e45acf6da89b3 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
                                                                 
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Semantics;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Xunit;
@@ -1046,7 +1047,7 @@ void M1()
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics, AdditionalOperationTreeVerifier: IndexerAccessArgumentVerifier.Verify);
         }
 
         [Fact]
@@ -1076,7 +1077,7 @@ void M1()
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics, AdditionalOperationTreeVerifier: IndexerAccessArgumentVerifier.Verify);
         }
 
         [Fact]
@@ -1109,7 +1110,7 @@ void M1()
 
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics, AdditionalOperationTreeVerifier: IndexerAccessArgumentVerifier.Verify);
         }
 
         [Fact]
@@ -1141,7 +1142,7 @@ void M1()
                 Diagnostic(ErrorCode.ERR_PropertyLacksGet, "this[10]").WithArguments("P.this[int]").WithLocation(12, 27)
             };
 
-            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics, AdditionalOperationTreeVerifier: IndexerAccessArgumentVerifier.Verify);
         }
 
         [Fact]
@@ -1175,9 +1176,117 @@ void M1()
                 Diagnostic(ErrorCode.ERR_AssgReadonlyProp, "this[10]").WithArguments("P.this[int]").WithLocation(12, 19)
             };
 
-            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
+            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics, AdditionalOperationTreeVerifier: IndexerAccessArgumentVerifier.Verify);
         }
 
+        [Fact]
+        public void OverridingIndexerWithDefaultArgument()
+        {
+            string source = @"
+class Base
+{
+    public virtual int this[int x = 0, int y = 1]
+    {
+        set { }
+        get { System.Console.Write(y); return 0; }
+    }
+}
+
+class Derived : Base
+{
+    public override int this[int x = 8, int y = 9]
+    {
+        set { }
+    }
+}
+
+internal class P
+{
+    static void Main()
+    {
+        var d = new Derived();
+        var x = /*<bind>*/d[0]/*</bind>*/;
+    }
+}
+";
+            string expectedOperationTree = @"
+IIndexedPropertyReferenceExpression: System.Int32 Derived.this[[System.Int32 x = 8], [System.Int32 y = 9]] { set; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32) (Syntax: 'd[0]')
+  Instance Receiver: ILocalReferenceExpression: d (OperationKind.LocalReferenceExpression, Type: Derived) (Syntax: 'd')
+  Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '0')
+      ILiteralExpression (Text: 0) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: '0')
+    IArgument (ArgumentKind.DefaultValue, Matching Parameter: y) (OperationKind.Argument) (Syntax: 'd[0]')
+      ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 1) (Syntax: 'd[0]')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            string expectedOutput = @"1";
+
+            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics, AdditionalOperationTreeVerifier: IndexerAccessArgumentVerifier.Verify);                                      
+
+            CompileAndVerify(new[] { source }, new[] { SystemRef }, expectedOutput: expectedOutput);
+        }
+
+        [Fact]
+        public void OmittedParamArrayArgumentInIndexerAccess()
+        {
+            string source = @"
+class P
+{
+    public int this[int x, params int[] y]
+    {
+        set { }
+        get { return 0; }
+    }
+
+    public void M()
+    {
+        /*<bind>*/this[0]/*</bind>*/ = 0;
+    }
+}
+";
+            string expectedOperationTree = @"
+IIndexedPropertyReferenceExpression: System.Int32 P.this[System.Int32 x, params System.Int32[] y] { get; set; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32) (Syntax: 'this[0]')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Explicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'this')
+  Arguments(2): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '0')
+      ILiteralExpression (Text: 0) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: '0')
+    IArgument (ArgumentKind.ParamArray, Matching Parameter: y) (OperationKind.Argument) (Syntax: 'this[0]')
+      IArrayCreationExpression (Element Type: System.Int32) (OperationKind.ArrayCreationExpression, Type: System.Int32[]) (Syntax: 'this[0]')
+        Dimension Sizes(1): ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: 'this[0]')
+        Initializer: IArrayInitializer (0 elements) (OperationKind.ArrayInitializer) (Syntax: 'this[0]')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics, AdditionalOperationTreeVerifier: IndexerAccessArgumentVerifier.Verify);
+        }
+
+        [Fact]
+        public void AssigningToReturnsByRefIndexer()
+        {
+            string source = @"
+class P
+{
+    ref int this[int x]
+    {
+        get => throw null;
+    }
+
+    public void M()
+    {
+        /*<bind>*/this[0]/*</bind>*/ = 0;
+    }
+}
+";
+            string expectedOperationTree = @"
+IIndexedPropertyReferenceExpression: ref System.Int32 P.this[System.Int32 x] { get; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32, IsInvalid) (Syntax: 'this[0]')
+  Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Explicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'this')
+  Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '0')
+      ILiteralExpression (Text: 0) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: '0')
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyOperationTreeAndDiagnosticsForTest<ElementAccessExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics, AdditionalOperationTreeVerifier: IndexerAccessArgumentVerifier.Verify);
+        } 
+
         [ClrOnlyFact(ClrOnlyReason.Ilasm)]
         public void AssigningToIndexer_UsingDefaultArgumentFromSetter()
         {
@@ -1205,15 +1314,25 @@ .method public hidebysig specialname instance int32
   {
     .param [1] = int32(0x00000001)
     .param [2] = int32(0x00000002)
-    // Code size       7 (0x7)
-    .maxstack  1
+    // Code size       35 (0x23)
+    .maxstack  3
     .locals init ([0] int32 V_0)
     IL_0000:  nop
-    IL_0001:  ldc.i4.0
-    IL_0002:  stloc.0
-    IL_0003:  br.s       IL_0005
-    IL_0005:  ldloc.0
-    IL_0006:  ret
+    IL_0001:  ldstr      ""{0} {1}""
+    IL_0006:  ldarg.1
+    IL_0007:  box        [mscorlib]System.Int32
+    IL_000c:  ldarg.2
+    IL_000d:  box        [mscorlib]System.Int32
+    IL_0012:  call       string [mscorlib]System.String::Format(string,
+                                                                object,
+                                                                object)
+    IL_0017:  call       void [mscorlib]System.Console::WriteLine(string)
+    IL_001c:  nop
+    IL_001d:  ldc.i4.0
+    IL_001e:  stloc.0
+    IL_001f:  br.s       IL_0021
+    IL_0021:  ldloc.0
+    IL_0022:  ret
   } // end of method P::get_Item
   
   .method public hidebysig specialname instance void 
@@ -1223,10 +1342,20 @@ .method public hidebysig specialname instance void
   {
     .param [1] = int32(0x00000003)
     .param [2] = int32(0x00000004)
-    // Code size       2 (0x2)
+    // Code size       30 (0x1e)
     .maxstack  8
     IL_0000:  nop
-    IL_0001:  ret
+    IL_0001:  ldstr      ""{0} {1}""
+    IL_0006:  ldarg.1
+    IL_0007:  box        [mscorlib]System.Int32
+    IL_000c:  ldarg.2
+    IL_000d:  box        [mscorlib]System.Int32
+    IL_0012:  call       string [mscorlib]System.String::Format(string,
+                                                                object,
+                                                                object)
+    IL_0017:  call       void [mscorlib]System.Console::WriteLine(string)
+    IL_001c:  nop
+    IL_001d:  ret
   } // end of method P::set_Item
 
 
@@ -1245,7 +1374,7 @@ .property instance int32 Item(int32,
             var csharp = @"
 class C
 {
-    public void M1()
+    public static void Main(string[] args)
     {
          P p = new P();
          /*<bind>*/p[10]/*</bind>*/ = 9;
@@ -1260,8 +1389,12 @@ public void M1()
     IArgument (ArgumentKind.DefaultValue, Matching Parameter: j) (OperationKind.Argument) (Syntax: 'p[10]')
       ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 4) (Syntax: 'p[10]')";
             var expectedDiagnostics = DiagnosticDescription.None;
+            var expectedOutput = @"10 4
+";
 
-            VerifyOperationTreeAndDiagnosticsForTestWithIL<ElementAccessExpressionSyntax>(csharp, il, expectedOperationTree, expectedDiagnostics);
+            var ilReference = VerifyOperationTreeAndDiagnosticsForTestWithIL<ElementAccessExpressionSyntax>(csharp, il, expectedOperationTree, expectedDiagnostics, AdditionalOperationTreeVerifier: IndexerAccessArgumentVerifier.Verify);
+
+            CompileAndVerify(new[] { csharp }, new[] { SystemRef, ilReference }, expectedOutput: expectedOutput);
         }
 
         [ClrOnlyFact(ClrOnlyReason.Ilasm)]
@@ -1291,28 +1424,48 @@ .method public hidebysig specialname instance int32
   {
     .param [1] = int32(0x00000001)
     .param [2] = int32(0x00000002)
-    // Code size       7 (0x7)
-    .maxstack  1
+    // Code size       35 (0x23)
+    .maxstack  3
     .locals init ([0] int32 V_0)
     IL_0000:  nop
-    IL_0001:  ldc.i4.0
-    IL_0002:  stloc.0
-    IL_0003:  br.s       IL_0005
-    IL_0005:  ldloc.0
-    IL_0006:  ret
+    IL_0001:  ldstr      ""{0} {1}""
+    IL_0006:  ldarg.1
+    IL_0007:  box        [mscorlib]System.Int32
+    IL_000c:  ldarg.2
+    IL_000d:  box        [mscorlib]System.Int32
+    IL_0012:  call       string [mscorlib]System.String::Format(string,
+                                                                object,
+                                                                object)
+    IL_0017:  call       void [mscorlib]System.Console::WriteLine(string)
+    IL_001c:  nop
+    IL_001d:  ldc.i4.0
+    IL_001e:  stloc.0
+    IL_001f:  br.s       IL_0021
+    IL_0021:  ldloc.0
+    IL_0022:  ret
   } // end of method P::get_Item
   
   .method public hidebysig specialname instance void 
           set_Item([opt] int32 i,
                    [opt] int32 j,
                    int32 'value') cil managed
-  {
+  {    
     .param [1] = int32(0x00000003)
     .param [2] = int32(0x00000004)
-    // Code size       2 (0x2)
+    // Code size       30 (0x1e)
     .maxstack  8
     IL_0000:  nop
-    IL_0001:  ret
+    IL_0001:  ldstr      ""{0} {1}""
+    IL_0006:  ldarg.1
+    IL_0007:  box        [mscorlib]System.Int32
+    IL_000c:  ldarg.2
+    IL_000d:  box        [mscorlib]System.Int32
+    IL_0012:  call       string [mscorlib]System.String::Format(string,
+                                                                object,
+                                                                object)
+    IL_0017:  call       void [mscorlib]System.Console::WriteLine(string)
+    IL_001c:  nop
+    IL_001d:  ret
   } // end of method P::set_Item
 
 
@@ -1331,7 +1484,7 @@ .property instance int32 Item(int32,
             var csharp = @"
 class C
 {
-    public void M1()
+    public static void Main(string[] args)
     {
          P p = new P();
          var x = /*<bind>*/p[10]/*</bind>*/;
@@ -1348,7 +1501,12 @@ public void M1()
 ";
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyOperationTreeAndDiagnosticsForTestWithIL<ElementAccessExpressionSyntax>(csharp, il, expectedOperationTree, expectedDiagnostics);
+            var expectedOutput = @"10 2
+";
+
+            var ilReference = VerifyOperationTreeAndDiagnosticsForTestWithIL<ElementAccessExpressionSyntax>(csharp, il, expectedOperationTree, expectedDiagnostics, AdditionalOperationTreeVerifier: IndexerAccessArgumentVerifier.Verify);
+
+            CompileAndVerify(new[] { csharp }, new[] { SystemRef, ilReference }, expectedOutput: expectedOutput);
         }
 
         [ClrOnlyFact(ClrOnlyReason.Ilasm)]
@@ -1378,28 +1536,48 @@ .method public hidebysig specialname instance int32
   {
     .param [1] = int32(0x00000001)
     .param [2] = int32(0x00000002)
-    // Code size       7 (0x7)
-    .maxstack  1
+    // Code size       35 (0x23)
+    .maxstack  3
     .locals init ([0] int32 V_0)
     IL_0000:  nop
-    IL_0001:  ldc.i4.0
-    IL_0002:  stloc.0
-    IL_0003:  br.s       IL_0005
-    IL_0005:  ldloc.0
-    IL_0006:  ret
+    IL_0001:  ldstr      ""{0} {1}""
+    IL_0006:  ldarg.1
+    IL_0007:  box        [mscorlib]System.Int32
+    IL_000c:  ldarg.2
+    IL_000d:  box        [mscorlib]System.Int32
+    IL_0012:  call       string [mscorlib]System.String::Format(string,
+                                                                object,
+                                                                object)
+    IL_0017:  call       void [mscorlib]System.Console::WriteLine(string)
+    IL_001c:  nop
+    IL_001d:  ldc.i4.0
+    IL_001e:  stloc.0
+    IL_001f:  br.s       IL_0021
+    IL_0021:  ldloc.0
+    IL_0022:  ret
   } // end of method P::get_Item
   
   .method public hidebysig specialname instance void 
           set_Item([opt] int32 i,
                    [opt] int32 j,
                    int32 'value') cil managed
-  {
+  { 
     .param [1] = int32(0x00000003)
     .param [2] = int32(0x00000004)
-    // Code size       2 (0x2)
+    // Code size       30 (0x1e)
     .maxstack  8
     IL_0000:  nop
-    IL_0001:  ret
+    IL_0001:  ldstr      ""{0} {1}""
+    IL_0006:  ldarg.1
+    IL_0007:  box        [mscorlib]System.Int32
+    IL_000c:  ldarg.2
+    IL_000d:  box        [mscorlib]System.Int32
+    IL_0012:  call       string [mscorlib]System.String::Format(string,
+                                                                object,
+                                                                object)
+    IL_0017:  call       void [mscorlib]System.Console::WriteLine(string)
+    IL_001c:  nop
+    IL_001d:  ret
   } // end of method P::set_Item
 
 
@@ -1418,7 +1596,7 @@ .property instance int32 Item(int32,
             var csharp = @"
 class C
 {
-    public void M1()
+    public static void Main(string[] args)
     {
          P p = new P();
          /*<bind>*/p[10]/*</bind>*/ += 99;
@@ -1434,7 +1612,13 @@ public void M1()
       ILiteralExpression (OperationKind.LiteralExpression, Type: System.Int32, Constant: 2) (Syntax: 'p[10]')";
             var expectedDiagnostics = DiagnosticDescription.None;
 
-            VerifyOperationTreeAndDiagnosticsForTestWithIL<ElementAccessExpressionSyntax>(csharp, il, expectedOperationTree, expectedDiagnostics);
+            var expectedOutput = @"10 2
+10 2
+";
+
+            var ilReference = VerifyOperationTreeAndDiagnosticsForTestWithIL<ElementAccessExpressionSyntax>(csharp, il, expectedOperationTree, expectedDiagnostics, AdditionalOperationTreeVerifier: IndexerAccessArgumentVerifier.Verify);
+
+            CompileAndVerify(new[] { csharp }, new[] { SystemRef, ilReference }, expectedOutput: expectedOutput);
         }
 
         [ClrOnlyFact(ClrOnlyReason.Ilasm)]
@@ -1487,5 +1671,32 @@ public void M2()
 
             VerifyOperationTreeAndDiagnosticsForTestWithIL<InvocationExpressionSyntax>(csharp, il, expectedOperationTree, expectedDiagnostics);
         }
-    }
+
+        private class IndexerAccessArgumentVerifier : OperationWalker
+        {        
+            public static void Verify(IOperation operation)
+            {
+                var walker = new IndexerAccessArgumentVerifier();
+                walker.Visit(operation);             
+            }
+
+            public override void VisitIndexedPropertyReferenceExpression(IIndexedPropertyReferenceExpression operation)
+            {
+                if (operation.IsInvalid)
+                {
+                    return;
+                }
+
+                // Check if the parameter symbol for argument is corresponding to indexer instead of accessor.
+                var indexerSymbol = operation.Property;
+                foreach (var argument in operation.ArgumentsInEvaluationOrder)
+                {
+                    if (!argument.IsInvalid)
+                    {
+                        Assert.True(argument.Parameter.ContainingSymbol == indexerSymbol);
+                    }
+                }
+            }
+        }
+    }             
 }
\ No newline at end of file
diff --git a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
index 9d63fcee5b3ab..c3739daccc946 100644
--- a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
@@ -221,8 +221,8 @@ protected CompilationUtils.SemanticInfoSummary GetSemanticInfoForTest(string tes
             return GetSemanticInfoForTest<ExpressionSyntax>(testSrc);
         }
 
-        protected string GetOperationTreeForTest<TSyntaxNode>(CSharpCompilation compilation)
-            where TSyntaxNode: SyntaxNode
+        protected IOperation GetOperationForTest<TSyntaxNode>(CSharpCompilation compilation)
+            where TSyntaxNode : SyntaxNode
         {
             var tree = compilation.SyntaxTrees[0];
             var model = compilation.GetSemanticModel(tree);
@@ -232,7 +232,18 @@ protected string GetOperationTreeForTest<TSyntaxNode>(CSharpCompilation compilat
                 return null;
             }
 
-            var operation = model.GetOperationInternal(syntaxNode);
+            return model.GetOperationInternal(syntaxNode);
+        }
+
+        protected string GetOperationTreeForTest<TSyntaxNode>(CSharpCompilation compilation)
+            where TSyntaxNode: SyntaxNode
+        {
+            var operation = GetOperationForTest<TSyntaxNode>(compilation);
+            return operation != null ? OperationTreeVerifier.GetOperationTree(operation) : null;
+        }
+
+        protected string GetOperationTreeForTest(IOperation operation)  
+        {                                                                   
             return operation != null ? OperationTreeVerifier.GetOperationTree(operation) : null;
         }
 
@@ -243,11 +254,13 @@ protected string GetOperationTreeForTest<TSyntaxNode>(string testSrc, string exp
             return GetOperationTreeForTest<TSyntaxNode>(compilation);
         }
 
-        protected void VerifyOperationTreeForTest<TSyntaxNode>(CSharpCompilation compilation, string expectedOperationTree)
+        protected void VerifyOperationTreeForTest<TSyntaxNode>(CSharpCompilation compilation, string expectedOperationTree, Action<IOperation> AdditionalOperationTreeVerifier = null)
             where TSyntaxNode : SyntaxNode
         {
-            var actualOperationTree = GetOperationTreeForTest<TSyntaxNode>(compilation);
+            var actualOperation = GetOperationForTest<TSyntaxNode>(compilation);
+            var actualOperationTree = GetOperationTreeForTest(actualOperation);
             OperationTreeVerifier.Verify(expectedOperationTree, actualOperationTree);
+            AdditionalOperationTreeVerifier?.Invoke(actualOperation);
         }
 
         protected void VerifyOperationTreeForTest<TSyntaxNode>(string testSrc, string expectedOperationTree, CSharpCompilationOptions compilationOptions = null, CSharpParseOptions parseOptions = null)
@@ -257,29 +270,43 @@ protected void VerifyOperationTreeForTest<TSyntaxNode>(string testSrc, string ex
             OperationTreeVerifier.Verify(expectedOperationTree, actualOperationTree);
         }
 
-        protected void VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(CSharpCompilation compilation, string expectedOperationTree, DiagnosticDescription[] expectedDiagnostics)
+        protected void VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(CSharpCompilation compilation, string expectedOperationTree, DiagnosticDescription[] expectedDiagnostics, Action<IOperation> AdditionalOperationTreeVerifier = null)
             where TSyntaxNode : SyntaxNode
         {
             var actualDiagnostics = compilation.GetDiagnostics().Where(d => d.Severity != DiagnosticSeverity.Hidden);
             actualDiagnostics.Verify(expectedDiagnostics);
-            VerifyOperationTreeForTest<TSyntaxNode>(compilation, expectedOperationTree);
+            VerifyOperationTreeForTest<TSyntaxNode>(compilation, expectedOperationTree, AdditionalOperationTreeVerifier);
         }
 
         private static readonly MetadataReference[] s_defaultOperationReferences = new[] { SystemRef, SystemCoreRef, ValueTupleRef, SystemRuntimeFacadeRef };
 
-        protected void VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(string testSrc, string expectedOperationTree, DiagnosticDescription[] expectedDiagnostics, CSharpCompilationOptions compilationOptions = null, CSharpParseOptions parseOptions = null, MetadataReference[] additionalReferences = null)
+        protected void VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(string testSrc, 
+            string expectedOperationTree, 
+            DiagnosticDescription[] expectedDiagnostics, 
+            CSharpCompilationOptions compilationOptions = null, 
+            CSharpParseOptions parseOptions = null, 
+            MetadataReference[] additionalReferences = null,
+            Action<IOperation> AdditionalOperationTreeVerifier = null)
             where TSyntaxNode : SyntaxNode
         {
             var references = additionalReferences == null ? s_defaultOperationReferences : additionalReferences.Concat(s_defaultOperationReferences);
             var compilation = CreateStandardCompilation(testSrc, references, sourceFileName: "file.cs", options: compilationOptions ?? TestOptions.ReleaseDll, parseOptions: parseOptions);
-            VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(compilation, expectedOperationTree, expectedDiagnostics);
+            VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(compilation, expectedOperationTree, expectedDiagnostics, AdditionalOperationTreeVerifier);
         }
 
-        protected void VerifyOperationTreeAndDiagnosticsForTestWithIL<TSyntaxNode>(string testSrc, string ilSource, string expectedOperationTree, DiagnosticDescription[] expectedDiagnostics, CSharpCompilationOptions compilationOptions = null, CSharpParseOptions parseOptions = null, MetadataReference[] additionalReferences = null)
+        protected MetadataReference VerifyOperationTreeAndDiagnosticsForTestWithIL<TSyntaxNode>(string testSrc, 
+            string ilSource, 
+            string expectedOperationTree, 
+            DiagnosticDescription[] expectedDiagnostics, 
+            CSharpCompilationOptions compilationOptions = null, 
+            CSharpParseOptions parseOptions = null, 
+            MetadataReference[] additionalReferences = null,
+            Action<IOperation> AdditionalOperationTreeVerifier = null)
    where TSyntaxNode : SyntaxNode
         {
             var ilReference = CreateMetadataReferenceFromIlSource(ilSource);
-            VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(testSrc, expectedOperationTree, expectedDiagnostics, compilationOptions, parseOptions, new[] { ilReference });
+            VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(testSrc, expectedOperationTree, expectedDiagnostics, compilationOptions, parseOptions, new[] { ilReference }, AdditionalOperationTreeVerifier);
+            return ilReference;
         }  
     }
 }

From a97af6e1f0e7cd9b99f37706eabe3a49ea98775b Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Wed, 17 May 2017 02:43:45 -0700
Subject: [PATCH 266/284] Fix build break.

---
 .../FindReferences/Entries/DocumentSpanEntry.cs     | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs b/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs
index f32bade84b9c2..9e47ed3ffeb80 100644
--- a/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs
+++ b/src/VisualStudio/Core/Next/FindReferences/Entries/DocumentSpanEntry.cs
@@ -21,6 +21,7 @@
 using Microsoft.VisualStudio.PlatformUI;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
+using DocumentHighlighting = Microsoft.CodeAnalysis.DocumentHighlighting;
 
 namespace Microsoft.VisualStudio.LanguageServices.FindUsages
 {
@@ -33,14 +34,14 @@ internal partial class StreamingFindUsagesPresenter
         /// </summary>
         private class DocumentSpanEntry : AbstractDocumentSpanEntry
         {
-            private readonly HighlightSpanKind _spanKind;
+            private readonly DocumentHighlighting.HighlightSpanKind _spanKind;
             private readonly ClassifiedSpansAndHighlightSpan _classifiedSpansAndHighlights;
 
             public DocumentSpanEntry(
                 AbstractTableDataSourceFindUsagesContext context,
                 RoslynDefinitionBucket definitionBucket,
                 DocumentSpan documentSpan,
-                HighlightSpanKind spanKind,
+                DocumentHighlighting.HighlightSpanKind spanKind,
                 string documentName,
                 Guid projectGuid,
                 SourceText sourceText,
@@ -53,9 +54,9 @@ public DocumentSpanEntry(
 
             protected override IList<System.Windows.Documents.Inline> CreateLineTextInlines()
             {
-                var propertyId = _spanKind == HighlightSpanKind.Definition
+                var propertyId = _spanKind == DocumentHighlighting.HighlightSpanKind.Definition
                     ? DefinitionHighlightTag.TagId
-                    : _spanKind == HighlightSpanKind.WrittenReference
+                    : _spanKind == DocumentHighlighting.HighlightSpanKind.WrittenReference
                         ? WrittenReferenceHighlightTag.TagId
                         : ReferenceHighlightTag.TagId;
 
@@ -163,9 +164,9 @@ private ITextBuffer CreateNewBuffer()
                     _sourceText.ToString(), contentType);
 
                 // Create an appropriate highlight span on that buffer for the reference.
-                var key = _spanKind == HighlightSpanKind.Definition
+                var key = _spanKind == DocumentHighlighting.HighlightSpanKind.Definition
                     ? PredefinedPreviewTaggerKeys.DefinitionHighlightingSpansKey
-                    : _spanKind == HighlightSpanKind.WrittenReference
+                    : _spanKind == DocumentHighlighting.HighlightSpanKind.WrittenReference
                         ? PredefinedPreviewTaggerKeys.WrittenReferenceHighlightingSpansKey
                         : PredefinedPreviewTaggerKeys.ReferenceHighlightingSpansKey;
                 textBuffer.Properties.RemoveProperty(key);

From 193517065dc8bf020171136b1f5250f14006d9ba Mon Sep 17 00:00:00 2001
From: Charles Stoner <chucks@microsoft.com>
Date: Fri, 5 May 2017 11:43:07 -0700
Subject: [PATCH 267/284] LambdaRewriter should only assign proxies from locals
 in original frame in EE

---
 .../Portable/Compiler/MethodCompiler.cs       | 124 +++++-----
 .../Lowering/LambdaRewriter/LambdaRewriter.cs |  18 +-
 .../Lowering/SyntheticBoundNodeFactory.cs     |  12 +-
 .../Emit/CodeGen/CodeGenLocalFunctionTests.cs |   2 +-
 .../Symbols/EEMethodSymbol.cs                 | 214 +++++++++---------
 .../Test/ExpressionCompiler/LocalsTests.cs    |  65 +++++-
 .../Symbols/EEMethodSymbol.vb                 |  10 +-
 .../Test/ExpressionCompiler/LocalsTests.vb    |  44 ++++
 8 files changed, 296 insertions(+), 193 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
index 5fe5afe4942d1..663a85900db60 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
@@ -649,75 +649,75 @@ private void CompileSynthesizedMethods(TypeCompilationState compilationState)
                     var importChain = methodWithBody.ImportChainOpt;
                     compilationState.CurrentImportChain = importChain;
 
-                // We make sure that an asynchronous mutation to the diagnostic bag does not 
-                // confuse the method body generator by making a fresh bag and then loading
-                // any diagnostics emitted into it back into the main diagnostic bag.
-                var diagnosticsThisMethod = DiagnosticBag.GetInstance();
+                    // We make sure that an asynchronous mutation to the diagnostic bag does not 
+                    // confuse the method body generator by making a fresh bag and then loading
+                    // any diagnostics emitted into it back into the main diagnostic bag.
+                    var diagnosticsThisMethod = DiagnosticBag.GetInstance();
 
                     var method = methodWithBody.Method;
-                var lambda = method as SynthesizedLambdaMethod;
-                var variableSlotAllocatorOpt = ((object)lambda != null) ?
-                    _moduleBeingBuiltOpt.TryCreateVariableSlotAllocator(lambda, lambda.TopLevelMethod, diagnosticsThisMethod) :
-                    _moduleBeingBuiltOpt.TryCreateVariableSlotAllocator(method, method, diagnosticsThisMethod);
-
-                // Synthesized methods have no ordinal stored in custom debug information (only user-defined methods have ordinals).
-                // In case of async lambdas, which synthesize a state machine type during the following rewrite, the containing method has already been uniquely named, 
-                // so there is no need to produce a unique method ordinal for the corresponding state machine type, whose name includes the (unique) containing method name.
-                const int methodOrdinal = -1;
-                MethodBody emittedBody = null;
+                    var lambda = method as SynthesizedLambdaMethod;
+                    var variableSlotAllocatorOpt = ((object)lambda != null) ?
+                        _moduleBeingBuiltOpt.TryCreateVariableSlotAllocator(lambda, lambda.TopLevelMethod, diagnosticsThisMethod) :
+                        _moduleBeingBuiltOpt.TryCreateVariableSlotAllocator(method, method, diagnosticsThisMethod);
 
-                try
-                {
-                    // Local functions can be iterators as well as be async (lambdas can only be async), so we need to lower both iterators and async
-                    IteratorStateMachine iteratorStateMachine;
-                    BoundStatement loweredBody = IteratorRewriter.Rewrite(methodWithBody.Body, method, methodOrdinal, variableSlotAllocatorOpt, compilationState, diagnosticsThisMethod, out iteratorStateMachine);
-                    StateMachineTypeSymbol stateMachine = iteratorStateMachine;
+                    // Synthesized methods have no ordinal stored in custom debug information (only user-defined methods have ordinals).
+                    // In case of async lambdas, which synthesize a state machine type during the following rewrite, the containing method has already been uniquely named, 
+                    // so there is no need to produce a unique method ordinal for the corresponding state machine type, whose name includes the (unique) containing method name.
+                    const int methodOrdinal = -1;
+                    MethodBody emittedBody = null;
 
-                    if (!loweredBody.HasErrors)
+                    try
                     {
-                        AsyncStateMachine asyncStateMachine;
-                        loweredBody = AsyncRewriter.Rewrite(loweredBody, method, methodOrdinal, variableSlotAllocatorOpt, compilationState, diagnosticsThisMethod, out asyncStateMachine);
+                        // Local functions can be iterators as well as be async (lambdas can only be async), so we need to lower both iterators and async
+                        IteratorStateMachine iteratorStateMachine;
+                        BoundStatement loweredBody = IteratorRewriter.Rewrite(methodWithBody.Body, method, methodOrdinal, variableSlotAllocatorOpt, compilationState, diagnosticsThisMethod, out iteratorStateMachine);
+                        StateMachineTypeSymbol stateMachine = iteratorStateMachine;
 
-                        Debug.Assert(iteratorStateMachine == null || asyncStateMachine == null);
-                        stateMachine = stateMachine ?? asyncStateMachine;
-                    }
+                        if (!loweredBody.HasErrors)
+                        {
+                            AsyncStateMachine asyncStateMachine;
+                            loweredBody = AsyncRewriter.Rewrite(loweredBody, method, methodOrdinal, variableSlotAllocatorOpt, compilationState, diagnosticsThisMethod, out asyncStateMachine);
+
+                            Debug.Assert(iteratorStateMachine == null || asyncStateMachine == null);
+                            stateMachine = stateMachine ?? asyncStateMachine;
+                        }
 
-                    if (!diagnosticsThisMethod.HasAnyErrors() && !_globalHasErrors)
+                        if (!diagnosticsThisMethod.HasAnyErrors() && !_globalHasErrors)
+                        {
+                            emittedBody = GenerateMethodBody(
+                                _moduleBeingBuiltOpt,
+                                method,
+                                methodOrdinal,
+                                loweredBody,
+                                ImmutableArray<LambdaDebugInfo>.Empty,
+                                ImmutableArray<ClosureDebugInfo>.Empty,
+                                stateMachine,
+                                variableSlotAllocatorOpt,
+                                diagnosticsThisMethod,
+                                _debugDocumentProvider,
+                                method.GenerateDebugInfo ? importChain : null,
+                                emittingPdb: _emittingPdb,
+                                emitTestCoverageData: _emitTestCoverageData,
+                                dynamicAnalysisSpans: ImmutableArray<SourceSpan>.Empty);
+                        }
+                    }
+                    catch (BoundTreeVisitor.CancelledByStackGuardException ex)
                     {
-                        emittedBody = GenerateMethodBody(
-                            _moduleBeingBuiltOpt,
-                            method,
-                            methodOrdinal,
-                            loweredBody,
-                            ImmutableArray<LambdaDebugInfo>.Empty,
-                            ImmutableArray<ClosureDebugInfo>.Empty,
-                            stateMachine,
-                            variableSlotAllocatorOpt,
-                            diagnosticsThisMethod,
-                            _debugDocumentProvider,
-                            method.GenerateDebugInfo ? importChain : null,
-                            emittingPdb: _emittingPdb,
-                            emitTestCoverageData: _emitTestCoverageData,
-                            dynamicAnalysisSpans: ImmutableArray<SourceSpan>.Empty);
+                        ex.AddAnError(_diagnostics);
                     }
-                }
-                catch (BoundTreeVisitor.CancelledByStackGuardException ex)
-                {
-                    ex.AddAnError(_diagnostics);
-                }
 
-                _diagnostics.AddRange(diagnosticsThisMethod);
-                diagnosticsThisMethod.Free();
+                    _diagnostics.AddRange(diagnosticsThisMethod);
+                    diagnosticsThisMethod.Free();
 
-                // error while generating IL
-                if (emittedBody == null)
-                {
-                    break;
-                }
+                    // error while generating IL
+                    if (emittedBody == null)
+                    {
+                        break;
+                    }
 
-                _moduleBeingBuiltOpt.SetMethodBody(method, emittedBody);
+                    _moduleBeingBuiltOpt.SetMethodBody(method, emittedBody);
+                }
             }
-        }
             finally
             {
                 compilationState.CurrentImportChain = oldImportChain;
@@ -1143,7 +1143,7 @@ private void CompileMethod(
                             {
                                 if (processedInitializers.LoweredInitializers.Kind == BoundKind.StatementList)
                                 {
-                                    BoundStatementList lowered = (BoundStatementList) processedInitializers.LoweredInitializers;
+                                    BoundStatementList lowered = (BoundStatementList)processedInitializers.LoweredInitializers;
                                     boundStatements = boundStatements.Concat(lowered.Statements);
                                 }
                                 else
@@ -1235,7 +1235,7 @@ internal static BoundStatement LowerBodyOrInitializer(
                     previousSubmissionFields: previousSubmissionFields,
                     allowOmissionOfConditionalCalls: true,
                     instrumentForDynamicAnalysis: instrumentForDynamicAnalysis,
-                    debugDocumentProvider:debugDocumentProvider,
+                    debugDocumentProvider: debugDocumentProvider,
                     dynamicAnalysisSpans: ref dynamicAnalysisSpans,
                     diagnostics: diagnostics,
                     sawLambdas: out sawLambdas,
@@ -1288,7 +1288,7 @@ internal static BoundStatement LowerBodyOrInitializer(
                         lazyVariableSlotAllocator,
                         compilationState,
                         diagnostics,
-                        assignLocals: false);
+                        assignLocals: null);
                 }
 
                 if (bodyWithoutLambdas.HasErrors)
@@ -1359,7 +1359,7 @@ private static MethodBody GenerateMethodBody(
                 bool isAsyncStateMachine;
                 MethodSymbol kickoffMethod;
 
-                if (method is SynthesizedStateMachineMethod stateMachineMethod && 
+                if (method is SynthesizedStateMachineMethod stateMachineMethod &&
                     method.Name == WellKnownMemberNames.MoveNextMethodName)
                 {
                     kickoffMethod = stateMachineMethod.StateMachineType.KickoffMethod;
@@ -1387,9 +1387,9 @@ private static MethodBody GenerateMethodBody(
                     // So it is undesirable to consider these exceptions "user unhandled" since there may well be user code that is awaiting the task.
                     // This is a heuristic since it's possible that there is no user code awaiting the task.
                     moveNextBodyDebugInfoOpt = new AsyncMoveNextBodyDebugInfo(
-                        kickoffMethod, 
+                        kickoffMethod,
                         kickoffMethod.ReturnsVoid ? asyncCatchHandlerOffset : -1,
-                        asyncYieldPoints, 
+                        asyncYieldPoints,
                         asyncResumePoints);
                 }
                 else
diff --git a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
index 9830f0705377c..54ab0dc621792 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
@@ -98,10 +98,10 @@ public MappedLocalFunction(SynthesizedLambdaMethod symbol, ClosureKind closureKi
         // or the "this" parameter when at the top level.  Keys in this map are never constructed types.
         private readonly Dictionary<NamedTypeSymbol, Symbol> _framePointers = new Dictionary<NamedTypeSymbol, Symbol>();
 
-        // True if the rewritten tree should include assignments of the
-        // original locals to the lifted proxies. This is only useful for the
-        // expression evaluator where the original locals are left as is.
-        private readonly bool _assignLocals;
+        // The set of original locals that should be assigned to proxies
+        // if lifted. This is useful for the expression evaluator where
+        // the original locals are left as is.
+        private readonly HashSet<LocalSymbol> _assignLocals;
 
         // The current method or lambda being processed.
         private MethodSymbol _currentMethod;
@@ -159,7 +159,7 @@ private LambdaRewriter(
             VariableSlotAllocator slotAllocatorOpt,
             TypeCompilationState compilationState,
             DiagnosticBag diagnostics,
-            bool assignLocals)
+            HashSet<LocalSymbol> assignLocals)
             : base(slotAllocatorOpt, compilationState, diagnostics)
         {
             Debug.Assert(analysis != null);
@@ -207,7 +207,7 @@ protected override bool NeedsProxy(Symbol localOrParameter)
         /// <param name="slotAllocatorOpt">Slot allocator.</param>
         /// <param name="compilationState">The caller's buffer into which we produce additional methods to be emitted by the caller</param>
         /// <param name="diagnostics">Diagnostic bag for diagnostics</param>
-        /// <param name="assignLocals">The rewritten tree should include assignments of the original locals to the lifted proxies</param>
+        /// <param name="assignLocals">The set of original locals that should be assigned to proxies if lifted</param>
         public static BoundStatement Rewrite(
             BoundStatement loweredBody,
             NamedTypeSymbol thisType,
@@ -220,7 +220,7 @@ public static BoundStatement Rewrite(
             VariableSlotAllocator slotAllocatorOpt,
             TypeCompilationState compilationState,
             DiagnosticBag diagnostics,
-            bool assignLocals)
+            HashSet<LocalSymbol> assignLocals)
         {
             Debug.Assert((object)thisType != null);
             Debug.Assert(((object)thisParameter == null) || (thisParameter.Type == thisType));
@@ -748,12 +748,12 @@ private void InitVariableProxy(SyntaxNode syntax, Symbol symbol, LocalSymbol fra
                         break;
 
                     case SymbolKind.Local:
-                        if (!_assignLocals)
+                        var local = (LocalSymbol)symbol;
+                        if (_assignLocals == null || !_assignLocals.Contains(local))
                         {
                             return;
                         }
 
-                        var local = (LocalSymbol)symbol;
                         LocalSymbol localToUse;
                         if (!localMap.TryGetValue(local, out localToUse))
                         {
diff --git a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
index 3f4fe16167ae4..e96abbfb42c5a 100644
--- a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
@@ -6,12 +6,9 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Text;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Symbols;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
@@ -174,12 +171,13 @@ private void CheckCurrentType()
             {
                 Debug.Assert((object)TopLevelMethod == null || TopLevelMethod.ContainingType == CurrentType);
 
-                // In EE scenarios, lambdas are considered to be contained by the user-defined methods,
-                // rather than the EE-defined methods for which we are generating bound nodes.  This is
-                // because the containing symbols are used to determine the type of the "this" parameter,
-                // which we need to the user-defined types.
+                // In EE scenarios, lambdas and local functions are considered to be contained by the
+                // user-defined methods, rather than the EE-defined methods for which we are generating
+                // bound nodes. This is because the containing symbols are used to determine the type
+                // of the "this" parameter, which we need to be the user-defined types.
                 Debug.Assert((object)CurrentMethod == null ||
                     CurrentMethod.MethodKind == MethodKind.AnonymousFunction ||
+                    CurrentMethod.MethodKind == MethodKind.LocalFunction ||
                     CurrentMethod.ContainingType == CurrentType);
             }
         }
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLocalFunctionTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLocalFunctionTests.cs
index a8f09509a607a..0f1e7cddca389 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLocalFunctionTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLocalFunctionTests.cs
@@ -4038,7 +4038,7 @@ .locals init (Program.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
 }
 ");
         }
-        
+
         internal CompilationVerifier VerifyOutput(string source, string output, CSharpCompilationOptions options)
         {
             var comp = CreateCompilationWithMscorlib45AndCSruntime(source, options: options);
diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EEMethodSymbol.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EEMethodSymbol.cs
index c54d367c413dc..cb7651382ac85 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EEMethodSymbol.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EEMethodSymbol.cs
@@ -497,126 +497,130 @@ internal override void GenerateMethodBody(TypeCompilationState compilationState,
                     statementsBuilder.Add(new BoundReturnStatement(syntax, RefKind.None, expressionOpt: null));
                 }
 
-                var localsBuilder = ArrayBuilder<LocalSymbol>.GetInstance();
                 var localsSet = PooledHashSet<LocalSymbol>.GetInstance();
-                foreach (var local in this.LocalsForBinding)
-                {
-                    Debug.Assert(!localsSet.Contains(local));
-                    localsBuilder.Add(local);
-                    localsSet.Add(local);
-                }
-                foreach (var local in this.Locals)
+                try
                 {
-                    if (!localsSet.Contains(local))
+                    var localsBuilder = ArrayBuilder<LocalSymbol>.GetInstance();
+                    foreach (var local in this.LocalsForBinding)
                     {
                         Debug.Assert(!localsSet.Contains(local));
                         localsBuilder.Add(local);
                         localsSet.Add(local);
                     }
-                }
-                localsSet.Free();
-
-                body = new BoundBlock(syntax, localsBuilder.ToImmutableAndFree(), statementsBuilder.ToImmutableAndFree()) { WasCompilerGenerated = true };
-
-                Debug.Assert(!diagnostics.HasAnyErrors());
-                Debug.Assert(!body.HasErrors);
-
-                bool sawLambdas;
-                bool sawLocalFunctions;
-                bool sawAwaitInExceptionHandler;
-                ImmutableArray<SourceSpan> dynamicAnalysisSpans = ImmutableArray<SourceSpan>.Empty;
-                body = LocalRewriter.Rewrite(
-                    compilation: this.DeclaringCompilation,
-                    method: this,
-                    methodOrdinal: _methodOrdinal,
-                    containingType: _container,
-                    statement: body,
-                    compilationState: compilationState,
-                    previousSubmissionFields: null,
-                    allowOmissionOfConditionalCalls: false,
-                    instrumentForDynamicAnalysis: false,
-                    debugDocumentProvider: null,
-                    dynamicAnalysisSpans: ref dynamicAnalysisSpans,
-                    diagnostics: diagnostics,
-                    sawLambdas: out sawLambdas,
-                    sawLocalFunctions: out sawLocalFunctions,
-                    sawAwaitInExceptionHandler: out sawAwaitInExceptionHandler);
-
-                Debug.Assert(!sawAwaitInExceptionHandler);
-                Debug.Assert(dynamicAnalysisSpans.Length == 0);
-
-                if (body.HasErrors)
-                {
-                    return;
-                }
-
-                // Variables may have been captured by lambdas in the original method
-                // or in the expression, and we need to preserve the existing values of
-                // those variables in the expression. This requires rewriting the variables
-                // in the expression based on the closure classes from both the original
-                // method and the expression, and generating a preamble that copies
-                // values into the expression closure classes.
-                //
-                // Consider the original method:
-                // static void M()
-                // {
-                //     int x, y, z;
-                //     ...
-                //     F(() => x + y);
-                // }
-                // and the expression in the EE: "F(() => x + z)".
-                //
-                // The expression is first rewritten using the closure class and local <1>
-                // from the original method: F(() => <1>.x + z)
-                // Then lambda rewriting introduces a new closure class that includes
-                // the locals <1> and z, and a corresponding local <2>: F(() => <2>.<1>.x + <2>.z)
-                // And a preamble is added to initialize the fields of <2>:
-                //     <2> = new <>c__DisplayClass0();
-                //     <2>.<1> = <1>;
-                //     <2>.z = z;
-
-                // Rewrite "this" and "base" references to parameter in this method.
-                // Rewrite variables within body to reference existing display classes.
-                body = (BoundStatement)CapturedVariableRewriter.Rewrite(
-                    this.GenerateThisReference,
-                    compilation.Conversions,
-                    _displayClassVariables,
-                    body,
-                    diagnostics);
-
-                if (body.HasErrors)
-                {
-                    Debug.Assert(false, "Please add a test case capturing whatever caused this assert.");
-                    return;
-                }
+                    foreach (var local in this.Locals)
+                    {
+                        if (localsSet.Add(local))
+                        {
+                            localsBuilder.Add(local);
+                        }
+                    }
 
-                if (diagnostics.HasAnyErrors())
-                {
-                    return;
-                }
+                    body = new BoundBlock(syntax, localsBuilder.ToImmutableAndFree(), statementsBuilder.ToImmutableAndFree()) { WasCompilerGenerated = true };
 
-                if (sawLambdas || sawLocalFunctions)
-                {
-                    var closureDebugInfoBuilder = ArrayBuilder<ClosureDebugInfo>.GetInstance();
-                    var lambdaDebugInfoBuilder = ArrayBuilder<LambdaDebugInfo>.GetInstance();
+                    Debug.Assert(!diagnostics.HasAnyErrors());
+                    Debug.Assert(!body.HasErrors);
 
-                    body = LambdaRewriter.Rewrite(
-                        loweredBody: body,
-                        thisType: this.SubstitutedSourceMethod.ContainingType,
-                        thisParameter: _thisParameter,
+                    bool sawLambdas;
+                    bool sawLocalFunctions;
+                    bool sawAwaitInExceptionHandler;
+                    ImmutableArray<SourceSpan> dynamicAnalysisSpans = ImmutableArray<SourceSpan>.Empty;
+                    body = LocalRewriter.Rewrite(
+                        compilation: this.DeclaringCompilation,
                         method: this,
                         methodOrdinal: _methodOrdinal,
-                        substitutedSourceMethod: this.SubstitutedSourceMethod.OriginalDefinition,
-                        closureDebugInfoBuilder: closureDebugInfoBuilder,
-                        lambdaDebugInfoBuilder: lambdaDebugInfoBuilder,
-                        slotAllocatorOpt: null,
+                        containingType: _container,
+                        statement: body,
                         compilationState: compilationState,
+                        previousSubmissionFields: null,
+                        allowOmissionOfConditionalCalls: false,
+                        instrumentForDynamicAnalysis: false,
+                        debugDocumentProvider: null,
+                        dynamicAnalysisSpans: ref dynamicAnalysisSpans,
                         diagnostics: diagnostics,
-                        assignLocals: true);
+                        sawLambdas: out sawLambdas,
+                        sawLocalFunctions: out sawLocalFunctions,
+                        sawAwaitInExceptionHandler: out sawAwaitInExceptionHandler);
+
+                    Debug.Assert(!sawAwaitInExceptionHandler);
+                    Debug.Assert(dynamicAnalysisSpans.Length == 0);
 
-                    // we don't need this information:
-                    closureDebugInfoBuilder.Free();
-                    lambdaDebugInfoBuilder.Free();
+                    if (body.HasErrors)
+                    {
+                        return;
+                    }
+
+                    // Variables may have been captured by lambdas in the original method
+                    // or in the expression, and we need to preserve the existing values of
+                    // those variables in the expression. This requires rewriting the variables
+                    // in the expression based on the closure classes from both the original
+                    // method and the expression, and generating a preamble that copies
+                    // values into the expression closure classes.
+                    //
+                    // Consider the original method:
+                    // static void M()
+                    // {
+                    //     int x, y, z;
+                    //     ...
+                    //     F(() => x + y);
+                    // }
+                    // and the expression in the EE: "F(() => x + z)".
+                    //
+                    // The expression is first rewritten using the closure class and local <1>
+                    // from the original method: F(() => <1>.x + z)
+                    // Then lambda rewriting introduces a new closure class that includes
+                    // the locals <1> and z, and a corresponding local <2>: F(() => <2>.<1>.x + <2>.z)
+                    // And a preamble is added to initialize the fields of <2>:
+                    //     <2> = new <>c__DisplayClass0();
+                    //     <2>.<1> = <1>;
+                    //     <2>.z = z;
+
+                    // Rewrite "this" and "base" references to parameter in this method.
+                    // Rewrite variables within body to reference existing display classes.
+                    body = (BoundStatement)CapturedVariableRewriter.Rewrite(
+                        this.GenerateThisReference,
+                        compilation.Conversions,
+                        _displayClassVariables,
+                        body,
+                        diagnostics);
+
+                    if (body.HasErrors)
+                    {
+                        Debug.Assert(false, "Please add a test case capturing whatever caused this assert.");
+                        return;
+                    }
+
+                    if (diagnostics.HasAnyErrors())
+                    {
+                        return;
+                    }
+
+                    if (sawLambdas || sawLocalFunctions)
+                    {
+                        var closureDebugInfoBuilder = ArrayBuilder<ClosureDebugInfo>.GetInstance();
+                        var lambdaDebugInfoBuilder = ArrayBuilder<LambdaDebugInfo>.GetInstance();
+
+                        body = LambdaRewriter.Rewrite(
+                            loweredBody: body,
+                            thisType: this.SubstitutedSourceMethod.ContainingType,
+                            thisParameter: _thisParameter,
+                            method: this,
+                            methodOrdinal: _methodOrdinal,
+                            substitutedSourceMethod: this.SubstitutedSourceMethod.OriginalDefinition,
+                            closureDebugInfoBuilder: closureDebugInfoBuilder,
+                            lambdaDebugInfoBuilder: lambdaDebugInfoBuilder,
+                            slotAllocatorOpt: null,
+                            compilationState: compilationState,
+                            diagnostics: diagnostics,
+                            assignLocals: localsSet);
+
+                        // we don't need this information:
+                        closureDebugInfoBuilder.Free();
+                        lambdaDebugInfoBuilder.Free();
+                    }
+                }
+                finally
+                {
+                    localsSet.Free();
                 }
 
                 // Insert locals from the original method,
diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs
index cc6469a7d005c..5d709ec89d7a2 100644
--- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs
+++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs
@@ -1426,12 +1426,11 @@ .locals init (C.<>c__DisplayClass1_0 V_0, //CS$<>8__locals0
             });
         }
 
-        [Fact(Skip = "18273"), WorkItem(18273, "https://github.com/dotnet/roslyn/issues/18273")]
+        [Fact, WorkItem(18273, "https://github.com/dotnet/roslyn/issues/18273")]
         public void CapturedLocalInNestedLambda()
         {
             var source = @"
 using System;
-
 class C
 {
     void M() { }
@@ -1440,11 +1439,69 @@ void M() { }
             WithRuntimeInstance(compilation0, runtime =>
             {
                 var context = CreateMethodContext(runtime, "C.M");
-
                 var testData = new CompilationTestData();
                 context.CompileExpression("new Action(() => { int x; new Func<int>(() => x).Invoke(); }).Invoke()", out var error, testData);
                 Assert.Null(error);
-                testData.GetMethodData("<>x.<>m0").VerifyIL("");
+                testData.GetMethodData("<>x.<>m0").VerifyIL(
+@"{
+  // Code size       37 (0x25)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action <>x.<>c.<>9__0_0""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001f
+  IL_0008:  pop
+  IL_0009:  ldsfld     ""<>x.<>c <>x.<>c.<>9""
+  IL_000e:  ldftn      ""void <>x.<>c.<<>m0>b__0_0()""
+  IL_0014:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0019:  dup
+  IL_001a:  stsfld     ""System.Action <>x.<>c.<>9__0_0""
+  IL_001f:  callvirt   ""void System.Action.Invoke()""
+  IL_0024:  ret
+}");
+            });
+        }
+
+        [Fact, WorkItem(18273, "https://github.com/dotnet/roslyn/issues/18273")]
+        public void CapturedLocalInNestedLocalFunction()
+        {
+            var source = @"
+using System;
+class C
+{
+    void M() { }
+}";
+            var compilation0 = CreateStandardCompilation(source, options: TestOptions.DebugDll);
+            WithRuntimeInstance(compilation0, runtime =>
+            {
+                var context = CreateMethodContext(runtime, "C.M");
+                var testData = new CompilationTestData();
+                context.CompileExpression(
+@"new Action<int>(x =>
+{
+    int y;
+    int F() => x + y;
+    F();
+}).Invoke(1)",
+                    out var error,
+                    testData);
+                Assert.Null(error);
+                testData.GetMethodData("<>x.<>m0").VerifyIL(
+@"{
+  // Code size       38 (0x26)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<int> <>x.<>c.<>9__0_0""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001f
+  IL_0008:  pop
+  IL_0009:  ldsfld     ""<>x.<>c <>x.<>c.<>9""
+  IL_000e:  ldftn      ""void <>x.<>c.<<>m0>b__0_0(int)""
+  IL_0014:  newobj     ""System.Action<int>..ctor(object, System.IntPtr)""
+  IL_0019:  dup
+  IL_001a:  stsfld     ""System.Action<int> <>x.<>c.<>9__0_0""
+  IL_001f:  ldc.i4.1
+  IL_0020:  callvirt   ""void System.Action<int>.Invoke(int)""
+  IL_0025:  ret
+}");
             });
         }
 
diff --git a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/Symbols/EEMethodSymbol.vb b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/Symbols/EEMethodSymbol.vb
index bfb03deca4811..d9c146d93106f 100644
--- a/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/Symbols/EEMethodSymbol.vb
+++ b/src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/Symbols/EEMethodSymbol.vb
@@ -471,7 +471,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
                 originalLocalsSet.Add(local)
             Next
             For Each local In Me.Locals
-                If Not originalLocalsSet.Contains(local) Then
+                If originalLocalsSet.Add(local) Then
                     originalLocalsBuilder.Add(local)
                 End If
             Next
@@ -555,10 +555,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
                 ' Rewrite references to "Me" to refer to this method's "Me" parameter.
                 ' Rewrite variables within body to reference existing display classes.
                 newBody = DirectCast(CapturedVariableRewriter.Rewrite(
-                If(Me.SubstitutedSourceMethod.IsShared, Nothing, Me.Parameters(0)),
-                displayClassVariables,
-                newBody,
-                diagnostics), BoundBlock)
+                    If(Me.SubstitutedSourceMethod.IsShared, Nothing, Me.Parameters(0)),
+                    displayClassVariables,
+                    newBody,
+                    diagnostics), BoundBlock)
 
                 If diagnostics.HasAnyErrors() Then
                     Return newBody
diff --git a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb
index dc4df811138a5..8acf5ee0432ac 100644
--- a/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb
+++ b/src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb
@@ -829,6 +829,50 @@ End Class
                 End Sub)
         End Sub
 
+        <Fact>
+        Public Sub CapturedLocalInNestedLambda()
+            Const source =
+"Imports System
+Class C
+    Shared Sub M()
+    End Sub
+    Shared Sub F(a As Action)
+    End Sub
+End Class"
+            Dim comp = CreateCompilationWithMscorlib({source}, options:=TestOptions.DebugDll)
+            WithRuntimeInstance(comp,
+                Sub(runtime)
+                    Dim context = CreateMethodContext(runtime, "C.M")
+                    Dim testData As New CompilationTestData()
+                    Dim errorMessage As String = Nothing
+                    context.CompileExpression(
+"F(Sub()
+        Dim x As Integer
+        Dim y As New Func(Of Integer)(Function() x)
+        y.Invoke()
+    End Sub)",
+                        errorMessage,
+                        testData)
+                    Assert.Null(errorMessage)
+                    testData.GetMethodData("<>x.<>m0").VerifyIL(
+"{
+  // Code size       42 (0x2a)
+  .maxstack  2
+  IL_0000:  ldsfld     ""<>x._Closure$__.$I0-0 As System.Action""
+  IL_0005:  brfalse.s  IL_000e
+  IL_0007:  ldsfld     ""<>x._Closure$__.$I0-0 As System.Action""
+  IL_000c:  br.s       IL_0024
+  IL_000e:  ldsfld     ""<>x._Closure$__.$I As <>x._Closure$__""
+  IL_0013:  ldftn      ""Sub <>x._Closure$__._Lambda$__0-0()""
+  IL_0019:  newobj     ""Sub System.Action..ctor(Object, System.IntPtr)""
+  IL_001e:  dup
+  IL_001f:  stsfld     ""<>x._Closure$__.$I0-0 As System.Action""
+  IL_0024:  call       ""Sub C.F(System.Action)""
+  IL_0029:  ret
+}")
+                End Sub)
+        End Sub
+
         <Fact>
         Public Sub NestedLambdas()
             Const source = "

From 123640de125bb347300ff55f9e121100b7d3aebc Mon Sep 17 00:00:00 2001
From: filipw <wojcieszyn@gmail.com>
Date: Wed, 22 Feb 2017 15:36:08 +0100
Subject: [PATCH 268/284] enable symbols in CSI

---
 .../Core/Hosting/CommandLine/CommandLineRunner.cs         | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs b/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
index d3bd825f0fe3f..6f519827bc094 100644
--- a/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
+++ b/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
@@ -126,7 +126,7 @@ private int RunInteractiveCore(ErrorLogger errorLogger)
             }
             else
             {
-                return RunScript(scriptOptions, code.ToString(), errorLogger, cancellationToken);
+                return RunScript(scriptOptions, code, errorLogger, cancellationToken);
             }
         }
 
@@ -150,7 +150,7 @@ private static ScriptOptions GetScriptOptions(CommandLineArguments arguments, st
                 namespaces: CommandLineHelpers.GetImports(arguments),
                 metadataResolver: metadataResolver,
                 sourceResolver: sourceResolver,
-                emitDebugInformation: false,
+                emitDebugInformation: true,
                 fileEncoding: null);
         }
 
@@ -173,12 +173,12 @@ internal static SourceReferenceResolver GetSourceReferenceResolver(CommandLineAr
             return new CommonCompiler.LoggingSourceFileResolver(arguments.SourcePaths, arguments.BaseDirectory, ImmutableArray<KeyValuePair<string, string>>.Empty, loggerOpt);
         }
 
-        private int RunScript(ScriptOptions options, string code, ErrorLogger errorLogger, CancellationToken cancellationToken)
+        private int RunScript(ScriptOptions options, SourceText code, ErrorLogger errorLogger, CancellationToken cancellationToken)
         {
             var globals = new CommandLineScriptGlobals(_console.Out, _objectFormatter);
             globals.Args.AddRange(_compiler.Arguments.ScriptArguments);
 
-            var script = Script.CreateInitialScript<int>(_scriptCompiler, SourceText.From(code), options, globals.GetType(), assemblyLoaderOpt: null);
+            var script = Script.CreateInitialScript<int>(_scriptCompiler, code, options, globals.GetType(), assemblyLoaderOpt: null);
             try
             {
                 return script.RunAsync(globals, cancellationToken).Result.ReturnValue;

From 4ddd86dac07f153fd4519368bd2a5c1df6a00296 Mon Sep 17 00:00:00 2001
From: filipw <wojcieszyn@gmail.com>
Date: Fri, 24 Feb 2017 23:44:12 +0100
Subject: [PATCH 269/284] improved decision logic around emitting symbols in
 CSI

---
 .../Core/Hosting/CommandLine/CommandLineRunner.cs        | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs b/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
index 6f519827bc094..8599e0e1164a4 100644
--- a/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
+++ b/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
@@ -109,7 +109,6 @@ private int RunInteractiveCore(ErrorLogger errorLogger)
             }
 
             var scriptPathOpt = sourceFiles.IsEmpty ? null : sourceFiles[0].Path;
-            var scriptOptions = GetScriptOptions(_compiler.Arguments, scriptPathOpt, _compiler.MessageProvider, diagnosticsInfos);
 
             var errors = _compiler.Arguments.Errors.Concat(diagnosticsInfos.Select(Diagnostic.Create));
             if (_compiler.ReportErrors(errors, _console.Error, errorLogger))
@@ -117,6 +116,10 @@ private int RunInteractiveCore(ErrorLogger errorLogger)
                 return CommonCompiler.Failed;
             }
 
+            // only emit symbols for non-interactive mode, and when encoding is known
+            var emitDebugInformation = !_compiler.Arguments.InteractiveMode && code.Encoding != null;
+            var scriptOptions = GetScriptOptions(_compiler.Arguments, scriptPathOpt, _compiler.MessageProvider, diagnosticsInfos, emitDebugInformation);
+
             var cancellationToken = new CancellationToken();
 
             if (_compiler.Arguments.InteractiveMode)
@@ -130,7 +133,7 @@ private int RunInteractiveCore(ErrorLogger errorLogger)
             }
         }
 
-        private static ScriptOptions GetScriptOptions(CommandLineArguments arguments, string scriptPathOpt, CommonMessageProvider messageProvider, List<DiagnosticInfo> diagnostics)
+        private static ScriptOptions GetScriptOptions(CommandLineArguments arguments, string scriptPathOpt, CommonMessageProvider messageProvider, List<DiagnosticInfo> diagnostics, bool emitDebugInformation)
         {
             var touchedFilesLoggerOpt = (arguments.TouchedFilesPath != null) ? new TouchedFileLogger() : null;
 
@@ -150,7 +153,7 @@ private static ScriptOptions GetScriptOptions(CommandLineArguments arguments, st
                 namespaces: CommandLineHelpers.GetImports(arguments),
                 metadataResolver: metadataResolver,
                 sourceResolver: sourceResolver,
-                emitDebugInformation: true,
+                emitDebugInformation: emitDebugInformation,
                 fileEncoding: null);
         }
 

From 38ac197753b8f59c3a55a0876f29d9fff217a571 Mon Sep 17 00:00:00 2001
From: filipw <wojcieszyn@gmail.com>
Date: Wed, 1 Mar 2017 09:26:38 +0100
Subject: [PATCH 270/284] move the script options back up

---
 .../Core/Hosting/CommandLine/CommandLineRunner.cs         | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs b/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
index 8599e0e1164a4..c54f6f678f64d 100644
--- a/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
+++ b/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
@@ -108,7 +108,12 @@ private int RunInteractiveCore(ErrorLogger errorLogger)
                 }
             }
 
+
+            // only emit symbols for non-interactive mode,
+            var emitDebugInformation = !_compiler.Arguments.InteractiveMode;
+
             var scriptPathOpt = sourceFiles.IsEmpty ? null : sourceFiles[0].Path;
+            var scriptOptions = GetScriptOptions(_compiler.Arguments, scriptPathOpt, _compiler.MessageProvider, diagnosticsInfos, emitDebugInformation);
 
             var errors = _compiler.Arguments.Errors.Concat(diagnosticsInfos.Select(Diagnostic.Create));
             if (_compiler.ReportErrors(errors, _console.Error, errorLogger))
@@ -116,9 +121,6 @@ private int RunInteractiveCore(ErrorLogger errorLogger)
                 return CommonCompiler.Failed;
             }
 
-            // only emit symbols for non-interactive mode, and when encoding is known
-            var emitDebugInformation = !_compiler.Arguments.InteractiveMode && code.Encoding != null;
-            var scriptOptions = GetScriptOptions(_compiler.Arguments, scriptPathOpt, _compiler.MessageProvider, diagnosticsInfos, emitDebugInformation);
 
             var cancellationToken = new CancellationToken();
 

From 59d9a6af2f4426f30dd6001a8e77017010443d36 Mon Sep 17 00:00:00 2001
From: filipw <wojcieszyn@gmail.com>
Date: Wed, 17 May 2017 11:39:39 +0200
Subject: [PATCH 271/284] added a PDB verification test to CsiTests

---
 src/Scripting/CSharpTest.Desktop/CsiTests.cs  | 21 +++++++++++++++++++
 .../Utilities/Portable/Assert/AssertEx.cs     |  7 +++++++
 2 files changed, 28 insertions(+)

diff --git a/src/Scripting/CSharpTest.Desktop/CsiTests.cs b/src/Scripting/CSharpTest.Desktop/CsiTests.cs
index cd1078df6206d..0364f17f4f6bf 100644
--- a/src/Scripting/CSharpTest.Desktop/CsiTests.cs
+++ b/src/Scripting/CSharpTest.Desktop/CsiTests.cs
@@ -2,6 +2,7 @@
 extern alias PortableTestUtils;
 
 using System;
+using System.IO;
 using System.Reflection;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
@@ -125,5 +126,25 @@ public void DefaultUsings()
             AssertEx.AssertEqualToleratingWhitespaceDifferences("OK", result.Output);
             Assert.False(result.ContainsErrors);
         }
+
+        [Fact]
+        public void LineNumber_Information_On_Exception()
+        {
+            var source = @"Console.WriteLine(""OK"");
+throw new Exception(""Error!"");
+";
+
+            var cwd = Temp.CreateDirectory();
+            cwd.CreateFile("a.csx").WriteAllText(source);
+
+            var result = ProcessUtilities.Run(CsiPath, "a.csx", workingDirectory: cwd.Path);
+
+            Assert.True(result.ContainsErrors);
+            AssertEx.AssertEqualToleratingWhitespaceDifferences("OK", result.Output);
+            AssertEx.AssertStartsWithToleratingWhitespaceDifferences($@"
+System.Exception: Error!
+   at Submission#0.<<Initialize>>d__0.MoveNext() in {cwd}{Path.DirectorySeparatorChar}a.csx:line 2
+", result.Errors);
+        }
     }
 }
diff --git a/src/Test/Utilities/Portable/Assert/AssertEx.cs b/src/Test/Utilities/Portable/Assert/AssertEx.cs
index b52bb6578990c..6a5d7c038c45e 100644
--- a/src/Test/Utilities/Portable/Assert/AssertEx.cs
+++ b/src/Test/Utilities/Portable/Assert/AssertEx.cs
@@ -392,6 +392,13 @@ public static void AssertContainsToleratingWhitespaceDifferences(string expected
             Assert.Contains(expectedSubString, actualString, StringComparison.Ordinal);
         }
 
+        public static void AssertStartsWithToleratingWhitespaceDifferences(string expectedSubString, string actualString)
+        {
+            expectedSubString = NormalizeWhitespace(expectedSubString);
+            actualString = NormalizeWhitespace(actualString);
+            Assert.StartsWith(expectedSubString, actualString, StringComparison.Ordinal);
+        }
+
         internal static string NormalizeWhitespace(string input)
         {
             var output = new StringBuilder();

From cff8fe3d472b11a7e477aa5bbd26cd99bb590109 Mon Sep 17 00:00:00 2001
From: filipw <wojcieszyn@gmail.com>
Date: Wed, 17 May 2017 11:49:26 +0200
Subject: [PATCH 272/284] use GetAwaiter() rather than .Result for script
 execution

---
 src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs b/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
index c54f6f678f64d..2ff968e89650b 100644
--- a/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
+++ b/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
@@ -186,7 +186,7 @@ private int RunScript(ScriptOptions options, SourceText code, ErrorLogger errorL
             var script = Script.CreateInitialScript<int>(_scriptCompiler, code, options, globals.GetType(), assemblyLoaderOpt: null);
             try
             {
-                return script.RunAsync(globals, cancellationToken).Result.ReturnValue;
+                return script.RunAsync(globals, cancellationToken).GetAwaiter().GetResult().ReturnValue;
             }
             catch (CompilationErrorException e)
             {

From cfd402cec48fb04ae2d250fcea276de0fb467daf Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Wed, 17 May 2017 14:11:27 -0700
Subject: [PATCH 273/284] Refactor and renaming

---
 .../Portable/Binder/Binder_Statements.cs      |  27 ++--
 .../CSharp/Portable/BoundTree/BoundNodes.xml  |   4 +-
 .../CSharp/Portable/BoundTree/Constructors.cs |   2 +-
 .../CSharp/Portable/BoundTree/Expression.cs   |   6 +-
 .../Generated/BoundNodes.xml.Generated.cs     |  16 +--
 .../LocalRewriter/LocalRewriter_Call.cs       | 131 ++++++++++--------
 ...ocalRewriter_CompoundAssignmentOperator.cs |   2 +-
 .../LocalRewriter/LocalRewriter_Conversion.cs |   2 +
 .../IOperation/IOperationTests_IArgument.cs   |   2 +-
 9 files changed, 106 insertions(+), 86 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
index 8ddf4b183f381..7a4aa8743ef91 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
@@ -1933,21 +1933,24 @@ private BoundExpression CheckValue(BoundExpression expr, BindValueKind valueKind
                         GetNonMethodMemberType(otherSymbol));
                 }
             }
-            else if (expr.Kind == BoundKind.IndexerAccess && valueKind == BindValueKind.Assignment)
+            else if (expr.Kind == BoundKind.IndexerAccess)
             {
-                // Assigning to an indexer access, need to set 'isLeftOfAssignment' to true.
+                // Assigning to an non ref return indexer needs to set 'useSetterForDefaultArgumentGeneration' to true. 
                 // This is for IOperation purpose.
                 var indexerAccess = (BoundIndexerAccess)expr;
-                expr = indexerAccess.Update(indexerAccess.ReceiverOpt,
-                    indexerAccess.Indexer,
-                    indexerAccess.Arguments,
-                    indexerAccess.ArgumentNamesOpt,
-                    indexerAccess.ArgumentRefKindsOpt,
-                    indexerAccess.Expanded,
-                    indexerAccess.ArgsToParamsOpt,
-                    indexerAccess.BinderOpt,
-                    isLeftOfAssignment: true,
-                    type: indexerAccess.Type);
+                if (valueKind == BindValueKind.Assignment && !indexerAccess.Indexer.ReturnsByRef)
+                {
+                    expr = indexerAccess.Update(indexerAccess.ReceiverOpt,
+                       indexerAccess.Indexer,
+                       indexerAccess.Arguments,
+                       indexerAccess.ArgumentNamesOpt,
+                       indexerAccess.ArgumentRefKindsOpt,
+                       indexerAccess.Expanded,
+                       indexerAccess.ArgsToParamsOpt,
+                       indexerAccess.BinderOpt,
+                       useSetterForDefaultArgumentGeneration: true,
+                       type: indexerAccess.Type);
+                }                
             }
 
             if (!hasResolutionErrors && CheckValueKind(expr, valueKind, diagnostics) ||
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index 7fac0d4f3de67..fca8f89687e1d 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -1498,9 +1498,9 @@
     <Field Name="Expanded" Type="bool"/>
     <Field Name="ArgsToParamsOpt" Type="ImmutableArray&lt;int&gt;" Null="allow"/>
 
-    <!-- BinderOpt and IsLeftOfAssignment are added as a temporary solution for IOperation implementation and should probably be removed in the future -->
+    <!-- BinderOpt and UseSetterForDefaultArgumentGeneration are added as a temporary solution for IOperation implementation and should probably be removed in the future -->
     <Field Name="BinderOpt" Type="Binder" Null="allow"/>
-    <Field Name="IsLeftOfAssignment" Type="bool"/>
+    <Field Name="UseSetterForDefaultArgumentGeneration" Type="bool"/>
   </Node>
 
   <Node Name="BoundDynamicIndexerAccess" Base="BoundExpression">
diff --git a/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs b/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
index 828728a47e4d5..a200b5636c2cd 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
@@ -164,7 +164,7 @@ public static BoundIndexerAccess ErrorAccess(
                 expanded: false,
                 argsToParamsOpt: default(ImmutableArray<int>),
                 binderOpt: null,
-                isLeftOfAssignment: false,
+                useSetterForDefaultArgumentGeneration: false,
                 type: indexer.Type,
                 hasErrors: true)
             {
diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index 8d2dbbadb61c0..5973853327246 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -215,7 +215,7 @@ ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder
         {
             get
             {
-                MethodSymbol accessor = this.IsLeftOfAssignment && !this.Indexer.ReturnsByRef 
+                MethodSymbol accessor = this.UseSetterForDefaultArgumentGeneration 
                     ? this.Indexer.GetOwnOrInheritedSetMethod() 
                     : this.Indexer.GetOwnOrInheritedGetMethod(); 
 
@@ -235,8 +235,8 @@ ImmutableArray<IArgument> IHasArgumentsExpression.ArgumentsInEvaluationOrder
 
         bool IOperation.IsInvalid
              => this.HasErrors 
-            || (this.Indexer.IsReadOnly && this.IsLeftOfAssignment) 
-            || (this.Indexer.IsWriteOnly && !this.IsLeftOfAssignment);
+            || (this.Indexer.IsReadOnly && this.UseSetterForDefaultArgumentGeneration) 
+            || (this.Indexer.IsWriteOnly && !this.UseSetterForDefaultArgumentGeneration);
 
         protected override OperationKind ExpressionKind => OperationKind.IndexedPropertyReferenceExpression;
 
diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
index 7f36d954c5543..d624e3ee0bab3 100644
--- a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
@@ -5424,7 +5424,7 @@ public BoundEventAccess Update(BoundExpression receiverOpt, EventSymbol eventSym
 
     internal sealed partial class BoundIndexerAccess : BoundExpression
     {
-        public BoundIndexerAccess(SyntaxNode syntax, BoundExpression receiverOpt, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, Binder binderOpt, bool isLeftOfAssignment, TypeSymbol type, bool hasErrors = false)
+        public BoundIndexerAccess(SyntaxNode syntax, BoundExpression receiverOpt, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, Binder binderOpt, bool useSetterForDefaultArgumentGeneration, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.IndexerAccess, syntax, type, hasErrors || receiverOpt.HasErrors() || arguments.HasErrors())
         {
 
@@ -5440,7 +5440,7 @@ public BoundIndexerAccess(SyntaxNode syntax, BoundExpression receiverOpt, Proper
             this.Expanded = expanded;
             this.ArgsToParamsOpt = argsToParamsOpt;
             this.BinderOpt = binderOpt;
-            this.IsLeftOfAssignment = isLeftOfAssignment;
+            this.UseSetterForDefaultArgumentGeneration = useSetterForDefaultArgumentGeneration;
         }
 
 
@@ -5460,18 +5460,18 @@ public BoundIndexerAccess(SyntaxNode syntax, BoundExpression receiverOpt, Proper
 
         public Binder BinderOpt { get; }
 
-        public bool IsLeftOfAssignment { get; }
+        public bool UseSetterForDefaultArgumentGeneration { get; }
 
         public override BoundNode Accept(BoundTreeVisitor visitor)
         {
             return visitor.VisitIndexerAccess(this);
         }
 
-        public BoundIndexerAccess Update(BoundExpression receiverOpt, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, Binder binderOpt, bool isLeftOfAssignment, TypeSymbol type)
+        public BoundIndexerAccess Update(BoundExpression receiverOpt, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, Binder binderOpt, bool useSetterForDefaultArgumentGeneration, TypeSymbol type)
         {
-            if (receiverOpt != this.ReceiverOpt || indexer != this.Indexer || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || argumentRefKindsOpt != this.ArgumentRefKindsOpt || expanded != this.Expanded || argsToParamsOpt != this.ArgsToParamsOpt || binderOpt != this.BinderOpt || isLeftOfAssignment != this.IsLeftOfAssignment || type != this.Type)
+            if (receiverOpt != this.ReceiverOpt || indexer != this.Indexer || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || argumentRefKindsOpt != this.ArgumentRefKindsOpt || expanded != this.Expanded || argsToParamsOpt != this.ArgsToParamsOpt || binderOpt != this.BinderOpt || useSetterForDefaultArgumentGeneration != this.UseSetterForDefaultArgumentGeneration || type != this.Type)
             {
-                var result = new BoundIndexerAccess(this.Syntax, receiverOpt, indexer, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, binderOpt, isLeftOfAssignment, type, this.HasErrors);
+                var result = new BoundIndexerAccess(this.Syntax, receiverOpt, indexer, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, binderOpt, useSetterForDefaultArgumentGeneration, type, this.HasErrors);
                 result.WasCompilerGenerated = this.WasCompilerGenerated;
                 return result;
             }
@@ -9136,7 +9136,7 @@ public override BoundNode VisitIndexerAccess(BoundIndexerAccess node)
             BoundExpression receiverOpt = (BoundExpression)this.Visit(node.ReceiverOpt);
             ImmutableArray<BoundExpression> arguments = (ImmutableArray<BoundExpression>)this.VisitList(node.Arguments);
             TypeSymbol type = this.VisitType(node.Type);
-            return node.Update(receiverOpt, node.Indexer, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.BinderOpt, node.IsLeftOfAssignment, type);
+            return node.Update(receiverOpt, node.Indexer, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.BinderOpt, node.UseSetterForDefaultArgumentGeneration, type);
         }
         public override BoundNode VisitDynamicIndexerAccess(BoundDynamicIndexerAccess node)
         {
@@ -10617,7 +10617,7 @@ public override TreeDumperNode VisitIndexerAccess(BoundIndexerAccess node, objec
                 new TreeDumperNode("expanded", node.Expanded, null),
                 new TreeDumperNode("argsToParamsOpt", node.ArgsToParamsOpt, null),
                 new TreeDumperNode("binderOpt", node.BinderOpt, null),
-                new TreeDumperNode("isLeftOfAssignment", node.IsLeftOfAssignment, null),
+                new TreeDumperNode("useSetterForDefaultArgumentGeneration", node.UseSetterForDefaultArgumentGeneration, null),
                 new TreeDumperNode("type", node.Type, null)
             }
             );
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index c1b023b0f0d66..955f5c0604517 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -615,44 +615,32 @@ private void BuildStoresToTemps(
                 RefKind refKind = argumentRefKinds.RefKinds(a);
                 Debug.Assert(arguments[p] == null);
 
-                if (expanded && p == arguments.Length - 1)
+                // Unfortunately, we violate the specification and allow:
+                // M(int q, params int[] x) ... M(x : X(), q : Q());
+                // which means that we cannot bail out just because
+                // an argument of an expanded-form call corresponds to
+                // the parameter array. We need to make sure that the
+                // side effects of X() and Q() continue to happen in the right
+                // order here.
+                //
+                // Fortunately, we do disallow M(x : 123, x : 345, x : 456).
+                // 
+                // Here's what we'll do. If all the remaining arguments
+                // correspond to elements in the parameter array then 
+                // we can bail out here without creating any temporaries.
+                // The next step in the call rewriter will deal with gathering
+                // up the elements. 
+                //
+                // However, if there are other elements after this one
+                // that do not correspond to elements in the parameter array
+                // then we need to create a temporary as usual. The step that
+                // produces the parameter array will need to deal with that
+                // eventuality.
+                                                                                                          
+                if (IsBeginningOfParamArray(p, a, expanded, arguments.Length, rewrittenArguments, argsToParamsOpt, out int paramArrayArgumentCount) 
+                    && a + paramArrayArgumentCount == rewrittenArguments.Length)
                 {
-                    // Unfortunately, we violate the specification and allow:
-                    // M(int q, params int[] x) ... M(x : X(), q : Q());
-                    // which means that we cannot bail out just because
-                    // an argument of an expanded-form call corresponds to
-                    // the parameter array. We need to make sure that the
-                    // side effects of X() and Q() continue to happen in the right
-                    // order here.
-                    //
-                    // Fortunately, we do disallow M(x : 123, x : 345, x : 456).
-                    // 
-                    // Here's what we'll do. If all the remaining arguments
-                    // correspond to elements in the parameter array then 
-                    // we can bail out here without creating any temporaries.
-                    // The next step in the call rewriter will deal with gathering
-                    // up the elements. 
-                    //
-                    // However, if there are other elements after this one
-                    // that do not correspond to elements in the parameter array
-                    // then we need to create a temporary as usual. The step that
-                    // produces the parameter array will need to deal with that
-                    // eventuality.
-
-                    bool canBail = true;
-                    for (int remainingArgument = a + 1; remainingArgument < rewrittenArguments.Length; ++remainingArgument)
-                    {
-                        int remainingParameter = (!argsToParamsOpt.IsDefault) ? argsToParamsOpt[remainingArgument] : remainingArgument;
-                        if (remainingParameter != arguments.Length - 1)
-                        {
-                            canBail = false;
-                            break;
-                        }
-                    }
-                    if (canBail)
-                    {
-                        return;
-                    }
+                    return;
                 }
 
                 if (IsSafeForReordering(argument, refKind))
@@ -693,39 +681,33 @@ private static void BuildExplicitArgumentsInEvaluationOrder(
 
                 Debug.Assert(!processedParameters.Contains(p));
 
-                processedParameters.Add(p); 
+                processedParameters.Add(p);
+
+                ArgumentKind kind = ArgumentKind.Explicit;
 
-                bool isParamArray = false;
-                if (expanded && p == parameters.Length - 1)
+                if (IsBeginningOfParamArray(p, a, expanded, parameters.Length, arguments, argsToParamsOpt, out int paramArrayArgumentCount))
                 {
-                    isParamArray = true;
+                    int firstNonParamArrayArgumentIndex = a + paramArrayArgumentCount;
+                    Debug.Assert(firstNonParamArrayArgumentIndex <= arguments.Length);
 
-                    ArrayBuilder<BoundExpression> paramArray = ArrayBuilder<BoundExpression>.GetInstance();
-                    paramArray.Add(argument);
+                    kind = ArgumentKind.ParamArray;
+                    ArrayBuilder<BoundExpression> paramArray = ArrayBuilder<BoundExpression>.GetInstance(paramArrayArgumentCount);
 
-                    int remainingArgument = a + 1;
-                    for (; remainingArgument < arguments.Length; ++remainingArgument)
+                    for (int i = a; i < firstNonParamArrayArgumentIndex; ++i)
                     {
-                        int remainingParameter = (!argsToParamsOpt.IsDefault) ? argsToParamsOpt[remainingArgument] : remainingArgument;
-                        if (remainingParameter != parameters.Length - 1)
-                        {
-                            break;
-                        }
-                        else
-                        {
-                            paramArray.Add(arguments[remainingArgument]);
-                        }
+                        paramArray.Add(arguments[i]);
                     }
-                    // Set loop variable to index of the last processed argument.
-                    a = remainingArgument - 1;
+
+                    // Set loop variable so the value for next iteration will be the index of the first non param-array argument after param-array argument(s).
+                    a = firstNonParamArrayArgumentIndex - 1;
 
                     var paramArrayType = parameters[p].Type;
                     var arrayArgs = paramArray.ToImmutableAndFree();
 
                     argument = CreateParamArrayArgument(syntax, paramArrayType, arrayArgs, null, binder);
-                }
+                }  
 
-                argumentsBuilder.Add(BoundCall.CreateArgumentOperation(isParamArray ? ArgumentKind.ParamArray : ArgumentKind.Explicit, parameter, argument)); 
+                argumentsBuilder.Add(BoundCall.CreateArgumentOperation(kind, parameter, argument)); 
             }
 
             // Fill in parameters with missing arguments.
@@ -739,6 +721,39 @@ private static void BuildExplicitArgumentsInEvaluationOrder(
             processedParameters.Free();
         }
 
+        /// <summary>
+        /// Returns true if the given argument is the begining of a list of param array arguments (could be empty), otherwise returns false.
+        /// When returns true, numberOfParamArrayArguments is set to the number of param array arguments.
+        /// </summary>
+        private static bool IsBeginningOfParamArray(
+            int parameterIndex,
+            int argumentIndex,
+            bool expanded,
+            int parameterCount,
+            ImmutableArray<BoundExpression> arguments,
+            ImmutableArray<int> argsToParamsOpt,
+            out int numberOfParamArrayArguments)
+        {
+            numberOfParamArrayArguments = 0;
+
+            if (expanded && parameterIndex == parameterCount - 1)
+            {                       
+                int remainingArgument = argumentIndex + 1;
+                for (; remainingArgument < arguments.Length; ++remainingArgument)
+                {
+                    int remainingParameter = (!argsToParamsOpt.IsDefault) ? argsToParamsOpt[remainingArgument] : remainingArgument;
+                    if (remainingParameter != parameterCount - 1)
+                    {                     
+                        break;
+                    }
+                }
+                numberOfParamArrayArguments = remainingArgument - argumentIndex;
+                return true;
+            }
+
+            return false;
+        }
+
         private BoundExpression BuildParamsArray(
             SyntaxNode syntax,
             Symbol methodOrIndexer,
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs
index c1afe91fc325e..274599cdc9533 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CompoundAssignmentOperator.cs
@@ -329,7 +329,7 @@ private BoundIndexerAccess TransformIndexerAccess(BoundIndexerAccess indexerAcce
                 false,
                 default(ImmutableArray<int>),
                 null,
-                indexerAccess.IsLeftOfAssignment,
+                indexerAccess.UseSetterForDefaultArgumentGeneration,
                 indexerAccess.Type);
         }
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
index 633189e6c6302..94fa633b2e4a9 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
@@ -511,6 +511,8 @@ private static BoundExpression MakeConversionForIOperation(
                 return operand;
             }
 
+            // TODO: Consider doing constant folding for default parameter value conversion.
+            //       https://github.com/dotnet/roslyn/issues/19591
             return new BoundConversion(
                             syntax,
                             operand,
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index e45acf6da89b3..fb74de5f8bad3 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -1277,7 +1277,7 @@ public void M()
 }
 ";
             string expectedOperationTree = @"
-IIndexedPropertyReferenceExpression: ref System.Int32 P.this[System.Int32 x] { get; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32, IsInvalid) (Syntax: 'this[0]')
+IIndexedPropertyReferenceExpression: ref System.Int32 P.this[System.Int32 x] { get; } (OperationKind.IndexedPropertyReferenceExpression, Type: System.Int32) (Syntax: 'this[0]')
   Instance Receiver: IInstanceReferenceExpression (InstanceReferenceKind.Explicit) (OperationKind.InstanceReferenceExpression, Type: P) (Syntax: 'this')
   Arguments(1): IArgument (ArgumentKind.Explicit, Matching Parameter: x) (OperationKind.Argument) (Syntax: '0')
       ILiteralExpression (Text: 0) (OperationKind.LiteralExpression, Type: System.Int32, Constant: 0) (Syntax: '0')

From c5e64fe04bc82700477b554d94fa04031b28475f Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Wed, 17 May 2017 14:28:48 -0700
Subject: [PATCH 274/284] Address review comments

---
 .../CSharp/Portable/BoundTree/Expression.cs       |  9 ++-------
 .../Lowering/LocalRewriter/LocalRewriter_Call.cs  | 15 +++++----------
 .../IOperation/IOperationTests_IArgument.cs       |  2 +-
 .../Utilities/CSharp/SemanticModelTestBase.cs     |  2 +-
 4 files changed, 9 insertions(+), 19 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
index 5973853327246..7283f4640b5ab 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Expression.cs
@@ -119,16 +119,11 @@ internal static ImmutableArray<IArgument> DeriveArguments(
                     //TODO: https://github.com/dotnet/roslyn/issues/18722
                     //      Right now, for erroneous code, we exposes all expression in place of arguments as IArgument with Parameter set to null,
                     //      so user needs to check IsInvalid first before using anything we returned. Need to implement a new interface for invalid invocation instead.
-                    if (n.HasErrors || optionalParametersMethod == null)
+                    if (n.HasErrors || (object)optionalParametersMethod == null)
                     {
                         // optionalParametersMethod can be null if we are writing to a readonly indexer or reading from an writeonly indexer,
                         // in which case HasErrors property would be true, but we still want to treat this as invalid invocation.
-                        ArrayBuilder<IArgument> argumentsWithErrors = ArrayBuilder<IArgument>.GetInstance(boundArguments.Length);
-                        for (int a = 0; a < boundArguments.Length; ++a)
-                        {
-                            argumentsWithErrors.Add(CreateArgumentOperation(ArgumentKind.Explicit, null, boundArguments[a]));
-                        }
-                        return argumentsWithErrors.ToImmutableAndFree();
+                        return boundArguments.SelectAsArray(arg => CreateArgumentOperation(ArgumentKind.Explicit, null, arg));
                     }                                                                                           
 
                    return LocalRewriter.MakeArgumentsInEvaluationOrder(
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index 955f5c0604517..65f80c694c8a8 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -391,7 +391,7 @@ private ImmutableArray<BoundExpression> MakeArguments(
             ArrayBuilder<LocalSymbol> temporariesBuilder = ArrayBuilder<LocalSymbol>.GetInstance();
             rewrittenArguments = _factory.MakeTempsForDiscardArguments(rewrittenArguments, temporariesBuilder);
 
-            if (CanSkipRewriting(ref rewrittenArguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, out var isComReceiver))
+            if (CanSkipRewriting(rewrittenArguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, out var isComReceiver))
             {
                 temps = temporariesBuilder.ToImmutableAndFree();
                 return rewrittenArguments;
@@ -519,9 +519,7 @@ internal static ImmutableArray<IArgument> MakeArgumentsInEvaluationOrder(
 
             ArrayBuilder<IArgument> argumentsInEvaluationBuilder = ArrayBuilder<IArgument>.GetInstance(parameters.Length);
 
-            bool canSkipRewriting = CanSkipRewriting(ref arguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, out var isComReceiver); 
-
-            if (canSkipRewriting)
+            if (CanSkipRewriting(arguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, out var isComReceiver))
             {
                 // In this case, the invocation is not in expanded form and there's no named argument provided.
                 // So we just return list of arguments as is.   
@@ -529,7 +527,7 @@ internal static ImmutableArray<IArgument> MakeArgumentsInEvaluationOrder(
                 {                                                 
                     argumentsInEvaluationBuilder.Add(BoundCall.CreateArgumentOperation(ArgumentKind.Explicit, parameters[i], arguments[i]));
                 } 
-                return argumentsInEvaluationBuilder.ToImmutableAndFree(); ;
+                return argumentsInEvaluationBuilder.ToImmutableAndFree();
             }                                                                                                                   
 
             ArrayBuilder<ParameterSymbol> missingParametersBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameters.Length);
@@ -551,7 +549,7 @@ internal static ImmutableArray<IArgument> MakeArgumentsInEvaluationOrder(
 
         // temporariesBuilder will be null when factory is null.
         private static bool CanSkipRewriting(
-            ref ImmutableArray<BoundExpression> rewrittenArguments,
+            ImmutableArray<BoundExpression> rewrittenArguments,
             Symbol methodOrIndexer,
             bool expanded,
             ImmutableArray<int> argsToParamsOpt,
@@ -701,10 +699,7 @@ private static void BuildExplicitArgumentsInEvaluationOrder(
                     // Set loop variable so the value for next iteration will be the index of the first non param-array argument after param-array argument(s).
                     a = firstNonParamArrayArgumentIndex - 1;
 
-                    var paramArrayType = parameters[p].Type;
-                    var arrayArgs = paramArray.ToImmutableAndFree();
-
-                    argument = CreateParamArrayArgument(syntax, paramArrayType, arrayArgs, null, binder);
+                    argument = CreateParamArrayArgument(syntax, parameter.Type, paramArray.ToImmutableAndFree(), null, binder);
                 }  
 
                 argumentsBuilder.Add(BoundCall.CreateArgumentOperation(kind, parameter, argument)); 
diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index fb74de5f8bad3..f806d06f450b7 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -850,7 +850,7 @@ bool M2(
         }
 
         [Fact]
-        public void CallerInfoAttributesInvokedInFieldInitilizer()
+        public void CallerInfoAttributesInvokedInFieldInitializer()
         {
             string source = @"
 using System.Runtime.CompilerServices;
diff --git a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
index c3739daccc946..80abf4a6c392d 100644
--- a/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/SemanticModelTestBase.cs
@@ -302,7 +302,7 @@ protected MetadataReference VerifyOperationTreeAndDiagnosticsForTestWithIL<TSynt
             CSharpParseOptions parseOptions = null, 
             MetadataReference[] additionalReferences = null,
             Action<IOperation> AdditionalOperationTreeVerifier = null)
-   where TSyntaxNode : SyntaxNode
+            where TSyntaxNode : SyntaxNode
         {
             var ilReference = CreateMetadataReferenceFromIlSource(ilSource);
             VerifyOperationTreeAndDiagnosticsForTest<TSyntaxNode>(testSrc, expectedOperationTree, expectedDiagnostics, compilationOptions, parseOptions, new[] { ilReference }, AdditionalOperationTreeVerifier);

From dccba9f667fb43f7d6ba3dd039dd872712b3ca41 Mon Sep 17 00:00:00 2001
From: Filip W <wojcieszyn@gmail.com>
Date: Thu, 18 May 2017 00:29:42 +0300
Subject: [PATCH 275/284] removed empty line

---
 src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs b/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
index 2ff968e89650b..ad2be82a1541f 100644
--- a/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
+++ b/src/Scripting/Core/Hosting/CommandLine/CommandLineRunner.cs
@@ -121,7 +121,6 @@ private int RunInteractiveCore(ErrorLogger errorLogger)
                 return CommonCompiler.Failed;
             }
 
-
             var cancellationToken = new CancellationToken();
 
             if (_compiler.Arguments.InteractiveMode)

From 683a457b97a7acb44ed897a9de1bb2346c9dceaf Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Wed, 17 May 2017 15:18:13 -0700
Subject: [PATCH 276/284] Add missing sequence point in lowering of conditional
 statement (#19336)

---
 .../LocalRewriter_IfStatement.cs              |   2 +
 .../LocalRewriter_ReturnStatement.cs          |   4 -
 .../Test/Emit/CodeGen/CodeGenLockTests.cs     |   6 +-
 .../EditAndContinue/LocalSlotMappingTests.cs  |  12 +-
 .../CSharp/Test/Emit/PDB/PDBAsyncTests.cs     |  13 +-
 .../CSharp/Test/Emit/PDB/PDBIteratorTests.cs  |   2 +
 .../CSharp/Test/Emit/PDB/PDBLambdaTests.cs    |   2 +
 .../CSharp/Test/Emit/PDB/PDBTests.cs          | 313 +++++++++++++++++-
 .../CSharp/Test/Emit/PDB/PDBTupleTests.cs     |   1 +
 .../CSharp/Test/Emit/PDB/PDBUsingTests.cs     |   2 +-
 10 files changed, 324 insertions(+), 33 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_IfStatement.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_IfStatement.cs
index 0c807fc1072f1..2305c3e63d718 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_IfStatement.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_IfStatement.cs
@@ -59,6 +59,7 @@ private static BoundStatement RewriteIfStatement(
 
                 builder.Add(new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, afterif));
                 builder.Add(rewrittenConsequence);
+                builder.Add(new BoundSequencePoint(null, null));
                 builder.Add(new BoundLabelStatement(syntax, afterif));
                 var statements = builder.ToImmutableAndFree();
                 return new BoundStatementList(syntax, statements, hasErrors);
@@ -86,6 +87,7 @@ private static BoundStatement RewriteIfStatement(
                 builder.Add(new BoundGotoStatement(syntax, afterif));
                 builder.Add(new BoundLabelStatement(syntax, alt));
                 builder.Add(rewrittenAlternativeOpt);
+                builder.Add(new BoundSequencePoint(null, null));
                 builder.Add(new BoundLabelStatement(syntax, afterif));
                 return new BoundStatementList(syntax, builder.ToImmutableAndFree(), hasErrors);
             }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ReturnStatement.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ReturnStatement.cs
index a611dffde4a0a..18b2442dbe4a7 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ReturnStatement.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ReturnStatement.cs
@@ -28,10 +28,6 @@ public override BoundNode VisitReturnStatement(BoundReturnStatement node)
             {
                 rewritten = _instrumenter.InstrumentReturnStatement(node, rewritten);
             }
-            else if (node.WasCompilerGenerated && _factory.CurrentMethod?.IsAsync == true)
-            {
-                rewritten = new BoundSequencePoint(null, rewritten);
-            }
 
             return rewritten;
         }
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLockTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLockTests.cs
index 6a0f3d1eeba35..7bca136e11e92 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLockTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLockTests.cs
@@ -57,7 +57,7 @@ .locals init (object V_0,
     IL_0023:  brfalse.s  IL_002b
     IL_0025:  ldloc.0
     IL_0026:  call       ""void System.Threading.Monitor.Exit(object)""
-    IL_002b:  endfinally
+   ~IL_002b:  endfinally
   }
  -IL_002c:  ldstr      ""After""
   IL_0031:  call       ""void System.Console.WriteLine(string)""
@@ -112,7 +112,7 @@ .locals init (object V_0,
     IL_0027:  brfalse.s  IL_002f
     IL_0029:  ldloc.0
     IL_002a:  call       ""void System.Threading.Monitor.Exit(object)""
-    IL_002f:  endfinally
+   ~IL_002f:  endfinally
   }
  -IL_0030:  ldstr      ""After""
   IL_0035:  call       ""void System.Console.WriteLine(string)""
@@ -387,7 +387,7 @@ .locals init (object V_0,
     IL_0027:  brfalse.s  IL_002f
     IL_0029:  ldloc.0
     IL_002a:  call       ""void System.Threading.Monitor.Exit(object)""
-    IL_002f:  endfinally
+   ~IL_002f:  endfinally
   }
  -IL_0030:  ldstr      ""After""
   IL_0035:  call       ""void System.Console.WriteLine(string)""
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/LocalSlotMappingTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/LocalSlotMappingTests.cs
index 7dce777325afd..2ceeac1661b2f 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/LocalSlotMappingTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/LocalSlotMappingTests.cs
@@ -349,10 +349,12 @@ static void M()
         <entry offset=""0x12"" startLine=""9"" startColumn=""20"" endLine=""9"" endColumn=""21"" />
         <entry offset=""0x13"" startLine=""9"" startColumn=""22"" endLine=""9"" endColumn=""23"" />
         <entry offset=""0x16"" hidden=""true"" />
+        <entry offset=""0x20"" hidden=""true"" />
         <entry offset=""0x21"" startLine=""10"" startColumn=""9"" endLine=""10"" endColumn=""20"" />
         <entry offset=""0x27"" startLine=""10"" startColumn=""21"" endLine=""10"" endColumn=""22"" />
         <entry offset=""0x28"" startLine=""10"" startColumn=""23"" endLine=""10"" endColumn=""24"" />
         <entry offset=""0x2b"" hidden=""true"" />
+        <entry offset=""0x35"" hidden=""true"" />
         <entry offset=""0x36"" startLine=""11"" startColumn=""5"" endLine=""11"" endColumn=""6"" />
       </sequencePoints>
     </method>
@@ -370,9 +372,11 @@ static void M()
         <entry offset=""0x0"" startLine=""9"" startColumn=""9"" endLine=""9"" endColumn=""19"" />
         <entry offset=""0x10"" startLine=""9"" startColumn=""22"" endLine=""9"" endColumn=""23"" />
         <entry offset=""0x12"" hidden=""true"" />
+        <entry offset=""0x1b"" hidden=""true"" />
         <entry offset=""0x1c"" startLine=""10"" startColumn=""9"" endLine=""10"" endColumn=""20"" />
         <entry offset=""0x22"" startLine=""10"" startColumn=""23"" endLine=""10"" endColumn=""24"" />
         <entry offset=""0x24"" hidden=""true"" />
+        <entry offset=""0x2d"" hidden=""true"" />
         <entry offset=""0x2e"" startLine=""11"" startColumn=""5"" endLine=""11"" endColumn=""6"" />
       </sequencePoints>
     </method>
@@ -559,7 +563,7 @@ .locals init (object V_0,
       IL_002b:  ldloc.2
       IL_002c:  call       ""void System.Threading.Monitor.Exit(object)""
       IL_0031:  nop
-      IL_0032:  endfinally
+     ~IL_0032:  endfinally
     }
    -IL_0033:  nop
     IL_0034:  leave.s    IL_0041
@@ -571,7 +575,7 @@ .locals init (object V_0,
     IL_0039:  ldloc.0
     IL_003a:  call       ""void System.Threading.Monitor.Exit(object)""
     IL_003f:  nop
-    IL_0040:  endfinally
+   ~IL_0040:  endfinally
   }
  -IL_0041:  ret
 }
@@ -1787,7 +1791,7 @@ .locals init (object V_0,
     IL_0010:  ldloc.s    V_6
     IL_0012:  callvirt   ""void System.IDisposable.Dispose()""
     IL_0017:  nop
-    IL_0018:  endfinally
+   ~IL_0018:  endfinally
   }
  -IL_0019:  call       ""object C.F1()""
   IL_001e:  stloc.0
@@ -1810,7 +1814,7 @@ .locals init (object V_0,
     IL_0031:  ldloc.0
     IL_0032:  call       ""void System.Threading.Monitor.Exit(object)""
     IL_0037:  nop
-    IL_0038:  endfinally
+   ~IL_0038:  endfinally
   }
  -IL_0039:  nop
  -IL_003a:  call       ""string C.F2()""
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBAsyncTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBAsyncTests.cs
index 12af52598331f..44decd73a817f 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBAsyncTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBAsyncTests.cs
@@ -159,7 +159,7 @@ .locals init (int V_0,
    -IL_00e5:  ldsfld     ""System.Threading.AutoResetEvent Driver.CompletedSignal""
     IL_00ea:  callvirt   ""bool System.Threading.EventWaitHandle.Set()""
     IL_00ef:  pop
-   ~IL_00f0:  leave.s    IL_010c
+    IL_00f0:  leave.s    IL_010c
   }
   catch System.Exception
   {
@@ -288,7 +288,6 @@ .locals init (int V_0,
         <entry offset=""0xcd"" startLine=""18"" startColumn=""24"" endLine=""18"" endColumn=""32"" />
         <entry offset=""0xd9"" startLine=""20"" startColumn=""9"" endLine=""20"" endColumn=""44"" />
         <entry offset=""0xe5"" startLine=""22"" startColumn=""9"" endLine=""22"" endColumn=""38"" />
-        <entry offset=""0xf0"" hidden=""true"" />
         <entry offset=""0xf2"" hidden=""true"" />
         <entry offset=""0x10c"" startLine=""23"" startColumn=""5"" endLine=""23"" endColumn=""6"" />
         <entry offset=""0x114"" hidden=""true"" />
@@ -444,7 +443,6 @@ private Task<int> GetNextInt(Random random)
         <entry offset=""0xe"" startLine=""16"" startColumn=""9"" endLine=""16"" endColumn=""10"" />
         <entry offset=""0xf"" startLine=""17"" startColumn=""13"" endLine=""17"" endColumn=""26"" />
         <entry offset=""0x20"" hidden=""true"" />
-        <entry offset=""0x71"" hidden=""true"" />
         <entry offset=""0x73"" hidden=""true"" />
         <entry offset=""0x8b"" startLine=""18"" startColumn=""9"" endLine=""18"" endColumn=""10"" />
         <entry offset=""0x93"" hidden=""true"" />
@@ -558,7 +556,6 @@ static async void Await(dynamic d)
         <entry offset=""0x11"" startLine=""5"" startColumn=""5"" endLine=""5"" endColumn=""6"" />
         <entry offset=""0x12"" startLine=""6"" startColumn=""9"" endLine=""6"" endColumn=""27"" />
         <entry offset=""0xae"" hidden=""true"" />
-        <entry offset=""0x22c"" hidden=""true"" />
         <entry offset=""0x22e"" hidden=""true"" />
         <entry offset=""0x248"" startLine=""7"" startColumn=""5"" endLine=""7"" endColumn=""6"" />
         <entry offset=""0x250"" hidden=""true"" />
@@ -756,7 +753,6 @@ static async Task M(int b)
         <entry offset=""0x25"" startLine=""13"" startColumn=""9"" endLine=""13"" endColumn=""47"" />
         <entry offset=""0x36"" startLine=""15"" startColumn=""9"" endLine=""15"" endColumn=""31"" />
         <entry offset=""0x55"" hidden=""true"" />
-        <entry offset=""0xa1"" hidden=""true"" />
         <entry offset=""0xa3"" hidden=""true"" />
         <entry offset=""0xba"" startLine=""16"" startColumn=""5"" endLine=""16"" endColumn=""6"" />
         <entry offset=""0xc2"" hidden=""true"" />
@@ -850,7 +846,6 @@ static async Task M(int b)
         <entry offset=""0x41"" startLine=""13"" startColumn=""9"" endLine=""13"" endColumn=""47"" />
         <entry offset=""0x58"" startLine=""15"" startColumn=""9"" endLine=""15"" endColumn=""31"" />
         <entry offset=""0x86"" hidden=""true"" />
-        <entry offset=""0xd7"" hidden=""true"" />
         <entry offset=""0xd9"" hidden=""true"" />
         <entry offset=""0xf1"" startLine=""19"" startColumn=""5"" endLine=""19"" endColumn=""6"" />
         <entry offset=""0xf9"" hidden=""true"" />
@@ -939,7 +934,6 @@ static async Task M(int b)
         <entry offset=""0x4f"" startLine=""15"" startColumn=""9"" endLine=""15"" endColumn=""29"" />
         <entry offset=""0x5b"" hidden=""true"" />
         <entry offset=""0xa7"" startLine=""17"" startColumn=""9"" endLine=""17"" endColumn=""31"" />
-        <entry offset=""0xb7"" hidden=""true"" />
         <entry offset=""0xb9"" hidden=""true"" />
         <entry offset=""0xd0"" startLine=""18"" startColumn=""5"" endLine=""18"" endColumn=""6"" />
         <entry offset=""0xd8"" hidden=""true"" />
@@ -1028,7 +1022,6 @@ static async Task M(int b)
         <entry offset=""0x58"" startLine=""15"" startColumn=""9"" endLine=""15"" endColumn=""29"" />
         <entry offset=""0x64"" hidden=""true"" />
         <entry offset=""0xb5"" startLine=""17"" startColumn=""9"" endLine=""17"" endColumn=""31"" />
-        <entry offset=""0xc6"" hidden=""true"" />
         <entry offset=""0xc8"" hidden=""true"" />
         <entry offset=""0xe0"" startLine=""18"" startColumn=""5"" endLine=""18"" endColumn=""6"" />
         <entry offset=""0xe8"" hidden=""true"" />
@@ -1117,7 +1110,6 @@ static async Task M()
         <entry offset=""0x1b"" startLine=""9"" startColumn=""9"" endLine=""9"" endColumn=""29"" />
         <entry offset=""0x27"" hidden=""true"" />
         <entry offset=""0x7b"" startLine=""10"" startColumn=""9"" endLine=""10"" endColumn=""22"" />
-        <entry offset=""0xd3"" hidden=""true"" />
         <entry offset=""0xd5"" hidden=""true"" />
         <entry offset=""0xed"" startLine=""11"" startColumn=""5"" endLine=""11"" endColumn=""6"" />
         <entry offset=""0xf5"" hidden=""true"" />
@@ -1196,7 +1188,6 @@ static async Task M()
         <entry offset=""0x14"" startLine=""9"" startColumn=""9"" endLine=""9"" endColumn=""22"" />
         <entry offset=""0x64"" startLine=""10"" startColumn=""9"" endLine=""10"" endColumn=""29"" />
         <entry offset=""0x70"" hidden=""true"" />
-        <entry offset=""0xbc"" hidden=""true"" />
         <entry offset=""0xbe"" hidden=""true"" />
         <entry offset=""0xd5"" startLine=""11"" startColumn=""5"" endLine=""11"" endColumn=""6"" />
         <entry offset=""0xdd"" hidden=""true"" />
@@ -1284,7 +1275,6 @@ static async Task M()
         <entry offset=""0x1e"" startLine=""9"" startColumn=""9"" endLine=""9"" endColumn=""22"" />
         <entry offset=""0x76"" startLine=""10"" startColumn=""9"" endLine=""10"" endColumn=""29"" />
         <entry offset=""0x82"" hidden=""true"" />
-        <entry offset=""0xd3"" hidden=""true"" />
         <entry offset=""0xd5"" hidden=""true"" />
         <entry offset=""0xed"" startLine=""14"" startColumn=""5"" endLine=""14"" endColumn=""6"" />
         <entry offset=""0xf5"" hidden=""true"" />
@@ -1731,7 +1721,6 @@ async partial void M() {}
   Document: #1
   IL_0000: <hidden>
   IL_0007: (5, 28) - (5, 29)
-  IL_0008: <hidden>
   IL_000A: <hidden>
   IL_0022: (5, 29) - (5, 30)
   IL_002A: <hidden>
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBIteratorTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBIteratorTests.cs
index d5ddcde1afa3e..70fb385094fb2 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBIteratorTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBIteratorTests.cs
@@ -403,6 +403,7 @@ static void Main()
         <entry offset=""0x18"" startLine=""23"" startColumn=""13"" endLine=""23"" endColumn=""41"" />
         <entry offset=""0x1d"" startLine=""21"" startColumn=""24"" endLine=""21"" endColumn=""26"" />
         <entry offset=""0x27"" hidden=""true"" />
+        <entry offset=""0x30"" hidden=""true"" />
         <entry offset=""0x31"" startLine=""25"" startColumn=""5"" endLine=""25"" endColumn=""6"" />
       </sequencePoints>
       <scope startOffset=""0x0"" endOffset=""0x32"">
@@ -555,6 +556,7 @@ public static void Main()
         <entry offset=""0x17"" startLine=""46"" startColumn=""49"" endLine=""46"" endColumn=""50"" />
         <entry offset=""0x18"" startLine=""46"" startColumn=""24"" endLine=""46"" endColumn=""26"" />
         <entry offset=""0x22"" hidden=""true"" />
+        <entry offset=""0x2c"" hidden=""true"" />
         <entry offset=""0x2d"" startLine=""47"" startColumn=""5"" endLine=""47"" endColumn=""6"" />
       </sequencePoints>
       <scope startOffset=""0x0"" endOffset=""0x2e"">
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBLambdaTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBLambdaTests.cs
index 100c4222be539..5accc7aa57e88 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBLambdaTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBLambdaTests.cs
@@ -1314,8 +1314,10 @@ static void F()
         <entry offset=""0x4f"" startLine=""18"" startColumn=""13"" endLine=""18"" endColumn=""25"" />
         <entry offset=""0x61"" startLine=""19"" startColumn=""9"" endLine=""19"" endColumn=""10"" />
         <entry offset=""0x64"" hidden=""true"" />
+        <entry offset=""0x78"" hidden=""true"" />
         <entry offset=""0x79"" hidden=""true"" />
         <entry offset=""0x7b"" hidden=""true"" />
+        <entry offset=""0x8f"" hidden=""true"" />
         <entry offset=""0x90"" startLine=""20"" startColumn=""5"" endLine=""20"" endColumn=""6"" />
       </sequencePoints>
       <scope startOffset=""0x0"" endOffset=""0x91"">
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
index 667f45ffcd116..dad8fbff4d285 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
@@ -2649,6 +2649,7 @@ static void Main(string[] args)
         <entry offset=""0x3c"" startLine=""26"" startColumn=""13"" endLine=""26"" endColumn=""14"" />
         <entry offset=""0x3d"" startLine=""12"" startColumn=""28"" endLine=""12"" endColumn=""30"" />
         <entry offset=""0x47"" hidden=""true"" />
+        <entry offset=""0x51"" hidden=""true"" />
         <entry offset=""0x52"" startLine=""27"" startColumn=""9"" endLine=""27"" endColumn=""10"" />
       </sequencePoints>
       <scope startOffset=""0x0"" endOffset=""0x53"">
@@ -4486,16 +4487,20 @@ static void Main()
         <entry offset=""0xc"" startLine=""22"" startColumn=""62"" endLine=""22"" endColumn=""90"" />
         <entry offset=""0x17"" startLine=""23"" startColumn=""13"" endLine=""23"" endColumn=""47"" />
         <entry offset=""0x24"" hidden=""true"" />
+        <entry offset=""0x2e"" hidden=""true"" />
         <entry offset=""0x2f"" hidden=""true"" />
         <entry offset=""0x31"" hidden=""true"" />
+        <entry offset=""0x3b"" hidden=""true"" />
         <entry offset=""0x3c"" startLine=""25"" startColumn=""16"" endLine=""25"" endColumn=""60"" />
         <entry offset=""0x47"" startLine=""25"" startColumn=""62"" endLine=""25"" endColumn=""90"" />
         <entry offset=""0x52"" startLine=""26"" startColumn=""9"" endLine=""26"" endColumn=""10"" />
         <entry offset=""0x53"" startLine=""27"" startColumn=""13"" endLine=""27"" endColumn=""48"" />
         <entry offset=""0x5e"" startLine=""28"" startColumn=""9"" endLine=""28"" endColumn=""10"" />
         <entry offset=""0x61"" hidden=""true"" />
+        <entry offset=""0x6b"" hidden=""true"" />
         <entry offset=""0x6c"" hidden=""true"" />
         <entry offset=""0x6e"" hidden=""true"" />
+        <entry offset=""0x78"" hidden=""true"" />
         <entry offset=""0x79"" startLine=""31"" startColumn=""9"" endLine=""31"" endColumn=""10"" />
         <entry offset=""0x7a"" startLine=""33"" startColumn=""9"" endLine=""33"" endColumn=""10"" />
         <entry offset=""0x7b"" startLine=""34"" startColumn=""5"" endLine=""34"" endColumn=""6"" />
@@ -4515,8 +4520,8 @@ static void Main()
 </symbols>");
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/18844"), WorkItem(18844, "https://github.com/dotnet/roslyn/issues/18844")]
-        public void UsingStatement_Embedded()
+        [Fact, WorkItem(18844, "https://github.com/dotnet/roslyn/issues/18844")]
+        public void UsingStatement_EmbeddedConditional()
         {
             var source = @"
 class C
@@ -4590,6 +4595,7 @@ .locals init (bool V_0, //x
     IL_001d:  ldloc.2
     IL_001e:  callvirt   ""void System.IDisposable.Dispose()""
     IL_0023:  nop
+    // sequence point: <hidden>
     IL_0024:  endfinally
   }
   // sequence point: return value;
@@ -4603,6 +4609,302 @@ .locals init (bool V_0, //x
 ", sequencePoints: "C.F", source: source);
         }
 
+        [Fact, WorkItem(18844, "https://github.com/dotnet/roslyn/issues/18844")]
+        public void UsingStatement_EmbeddedConditional2()
+        {
+            var source = @"
+class C
+{
+    bool F()
+    {
+        bool x = true;
+        bool value = false;
+        using (var stream = new System.IO.MemoryStream())
+            if (x)
+            {
+                value = true;
+            }
+            else
+            {
+                value = false;
+            }
+
+        return value;
+    }
+}
+";
+
+            var c = CreateCompilationWithMscorlibAndSystemCore(source, options: TestOptions.DebugDll);
+            var v = CompileAndVerify(c);
+            v.VerifyIL("C.F", @"
+{
+  // Code size       47 (0x2f)
+  .maxstack  1
+  .locals init (bool V_0, //x
+                bool V_1, //value
+                System.IO.MemoryStream V_2, //stream
+                bool V_3,
+                bool V_4)
+  // sequence point: {
+  IL_0000:  nop
+  // sequence point: bool x = true;
+  IL_0001:  ldc.i4.1
+  IL_0002:  stloc.0
+  // sequence point: bool value = false;
+  IL_0003:  ldc.i4.0
+  IL_0004:  stloc.1
+  // sequence point: var stream = new System.IO.MemoryStream()
+  IL_0005:  newobj     ""System.IO.MemoryStream..ctor()""
+  IL_000a:  stloc.2
+  .try
+  {
+    // sequence point: if (x)
+    IL_000b:  ldloc.0
+    IL_000c:  stloc.3
+    // sequence point: <hidden>
+    IL_000d:  ldloc.3
+    IL_000e:  brfalse.s  IL_0016
+    // sequence point: {
+    IL_0010:  nop
+    // sequence point: value = true;
+    IL_0011:  ldc.i4.1
+    IL_0012:  stloc.1
+    // sequence point: }
+    IL_0013:  nop
+    IL_0014:  br.s       IL_001a
+    // sequence point: {
+    IL_0016:  nop
+    // sequence point: value = false;
+    IL_0017:  ldc.i4.0
+    IL_0018:  stloc.1
+    // sequence point: }
+    IL_0019:  nop
+    // sequence point: <hidden>
+    IL_001a:  leave.s    IL_0027
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_001c:  ldloc.2
+    IL_001d:  brfalse.s  IL_0026
+    IL_001f:  ldloc.2
+    IL_0020:  callvirt   ""void System.IDisposable.Dispose()""
+    IL_0025:  nop
+    // sequence point: <hidden>
+    IL_0026:  endfinally
+  }
+  // sequence point: return value;
+  IL_0027:  ldloc.1
+  IL_0028:  stloc.s    V_4
+  IL_002a:  br.s       IL_002c
+  // sequence point: }
+  IL_002c:  ldloc.s    V_4
+  IL_002e:  ret
+}
+", sequencePoints: "C.F", source: source);
+        }
+
+        [Fact, WorkItem(18844, "https://github.com/dotnet/roslyn/issues/18844")]
+        public void UsingStatement_EmbeddedWhile()
+        {
+            var source = @"
+class C
+{
+    void F(bool x)
+    {
+        using (var stream = new System.IO.MemoryStream())
+            while (x)
+                x = false;
+    }
+}
+";
+
+            var c = CreateCompilationWithMscorlibAndSystemCore(source, options: TestOptions.DebugDll);
+            var v = CompileAndVerify(c);
+            v.VerifyIL("C.F", @"
+{
+  // Code size       31 (0x1f)
+  .maxstack  1
+  .locals init (System.IO.MemoryStream V_0, //stream
+                bool V_1)
+  // sequence point: {
+  IL_0000:  nop
+  // sequence point: var stream = new System.IO.MemoryStream()
+  IL_0001:  newobj     ""System.IO.MemoryStream..ctor()""
+  IL_0006:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_0007:  br.s       IL_000c
+    // sequence point: x = false;
+    IL_0009:  ldc.i4.0
+    IL_000a:  starg.s    V_1
+    // sequence point: while (x)
+    IL_000c:  ldarg.1
+    IL_000d:  stloc.1
+    // sequence point: <hidden>
+    IL_000e:  ldloc.1
+    IL_000f:  brtrue.s   IL_0009
+    IL_0011:  leave.s    IL_001e
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0013:  ldloc.0
+    IL_0014:  brfalse.s  IL_001d
+    IL_0016:  ldloc.0
+    IL_0017:  callvirt   ""void System.IDisposable.Dispose()""
+    IL_001c:  nop
+    // sequence point: <hidden>
+    IL_001d:  endfinally
+  }
+  // sequence point: }
+  IL_001e:  ret
+}
+", sequencePoints: "C.F", source: source);
+        }
+
+        [Fact, WorkItem(18844, "https://github.com/dotnet/roslyn/issues/18844")]
+        public void UsingStatement_EmbeddedFor()
+        {
+            var source = @"
+class C
+{
+    void F(bool x)
+    {
+        using (var stream = new System.IO.MemoryStream())
+            for ( ; x == true; )
+                x = false;
+    }
+}
+";
+
+            var c = CreateCompilationWithMscorlibAndSystemCore(source, options: TestOptions.DebugDll);
+            var v = CompileAndVerify(c);
+            v.VerifyIL("C.F", @"
+{
+  // Code size       31 (0x1f)
+  .maxstack  1
+  .locals init (System.IO.MemoryStream V_0, //stream
+                bool V_1)
+  // sequence point: {
+  IL_0000:  nop
+  // sequence point: var stream = new System.IO.MemoryStream()
+  IL_0001:  newobj     ""System.IO.MemoryStream..ctor()""
+  IL_0006:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_0007:  br.s       IL_000c
+    // sequence point: x = false;
+    IL_0009:  ldc.i4.0
+    IL_000a:  starg.s    V_1
+    // sequence point: x == true
+    IL_000c:  ldarg.1
+    IL_000d:  stloc.1
+    // sequence point: <hidden>
+    IL_000e:  ldloc.1
+    IL_000f:  brtrue.s   IL_0009
+    IL_0011:  leave.s    IL_001e
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0013:  ldloc.0
+    IL_0014:  brfalse.s  IL_001d
+    IL_0016:  ldloc.0
+    IL_0017:  callvirt   ""void System.IDisposable.Dispose()""
+    IL_001c:  nop
+    // sequence point: <hidden>
+    IL_001d:  endfinally
+  }
+  // sequence point: }
+  IL_001e:  ret
+}
+", sequencePoints: "C.F", source: source);
+        }
+
+        [Fact, WorkItem(18844, "https://github.com/dotnet/roslyn/issues/18844")]
+        public void LockStatement_EmbeddedIf()
+        {
+            var source = @"
+class C
+{
+    void F(bool x)
+    {
+        string y = """";
+        lock (y)
+            if (!x)
+                System.Console.Write(1);
+            else
+                System.Console.Write(2);
+    }
+}
+";
+
+            var c = CreateCompilationWithMscorlibAndSystemCore(source, options: TestOptions.DebugDll);
+            var v = CompileAndVerify(c);
+            v.VerifyIL("C.F", @"
+{
+  // Code size       58 (0x3a)
+  .maxstack  2
+  .locals init (string V_0, //y
+                string V_1,
+                bool V_2,
+                bool V_3)
+  // sequence point: {
+  IL_0000:  nop
+  // sequence point: string y = """";
+  IL_0001:  ldstr      """"
+  IL_0006:  stloc.0
+  // sequence point: lock (y)
+  IL_0007:  ldloc.0
+  IL_0008:  stloc.1
+  IL_0009:  ldc.i4.0
+  IL_000a:  stloc.2
+  .try
+  {
+    IL_000b:  ldloc.1
+    IL_000c:  ldloca.s   V_2
+    IL_000e:  call       ""void System.Threading.Monitor.Enter(object, ref bool)""
+    IL_0013:  nop
+    // sequence point: if (!x)
+    IL_0014:  ldarg.1
+    IL_0015:  ldc.i4.0
+    IL_0016:  ceq
+    IL_0018:  stloc.3
+    // sequence point: <hidden>
+    IL_0019:  ldloc.3
+    IL_001a:  brfalse.s  IL_0025
+    // sequence point: System.Console.Write(1);
+    IL_001c:  ldc.i4.1
+    IL_001d:  call       ""void System.Console.Write(int)""
+    IL_0022:  nop
+    IL_0023:  br.s       IL_002c
+    // sequence point: System.Console.Write(2);
+    IL_0025:  ldc.i4.2
+    IL_0026:  call       ""void System.Console.Write(int)""
+    IL_002b:  nop
+    // sequence point: <hidden>
+    IL_002c:  leave.s    IL_0039
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_002e:  ldloc.2
+    IL_002f:  brfalse.s  IL_0038
+    IL_0031:  ldloc.1
+    IL_0032:  call       ""void System.Threading.Monitor.Exit(object)""
+    IL_0037:  nop
+    // sequence point: <hidden>
+    IL_0038:  endfinally
+  }
+  // sequence point: }
+  IL_0039:  ret
+}
+", sequencePoints: "C.F", source: source);
+        }
+
         #endregion
 
         // LockStatement tested in CodeGenLock
@@ -5986,7 +6288,6 @@ static async Task F()
         <entry offset=""0x7"" startLine=""6"" startColumn=""5"" endLine=""6"" endColumn=""6"" />
         <entry offset=""0x8"" startLine=""7"" startColumn=""9"" endLine=""7"" endColumn=""35"" />
         <entry offset=""0x1f"" startLine=""8"" startColumn=""9"" endLine=""8"" endColumn=""26"" />
-        <entry offset=""0x4a"" hidden=""true"" />
         <entry offset=""0x4c"" hidden=""true"" />
         <entry offset=""0x64"" startLine=""9"" startColumn=""5"" endLine=""9"" endColumn=""6"" />
         <entry offset=""0x6c"" hidden=""true"" />
@@ -6049,7 +6350,6 @@ static void M()
         <entry offset=""0x7"" startLine=""7"" startColumn=""9"" endLine=""7"" endColumn=""10"" />
         <entry offset=""0x8"" startLine=""8"" startColumn=""13"" endLine=""8"" endColumn=""39"" />
         <entry offset=""0x1f"" startLine=""9"" startColumn=""13"" endLine=""9"" endColumn=""30"" />
-        <entry offset=""0x4a"" hidden=""true"" />
         <entry offset=""0x4c"" hidden=""true"" />
         <entry offset=""0x64"" startLine=""10"" startColumn=""9"" endLine=""10"" endColumn=""10"" />
         <entry offset=""0x6c"" hidden=""true"" />
@@ -6367,7 +6667,6 @@ public async void M1()
       <sequencePoints>
         <entry offset=""0x0"" hidden=""true"" document=""1"" />
         <entry offset=""0x7"" startLine=""8"" startColumn=""5"" endLine=""8"" endColumn=""6"" document=""1"" />
-        <entry offset=""0x8"" hidden=""true"" document=""1"" />
         <entry offset=""0xa"" hidden=""true"" document=""1"" />
         <entry offset=""0x22"" startLine=""9"" startColumn=""5"" endLine=""9"" endColumn=""6"" document=""1"" />
         <entry offset=""0x2a"" hidden=""true"" document=""1"" />
@@ -6743,7 +7042,6 @@ .locals init (int V_0,
     IL_001a:  br.s       IL_001e
     // sequence point: break;
     IL_001c:  br.s       IL_001e
-    // sequence point: <hidden>
     IL_001e:  leave.s    IL_0038
   }
   catch System.Exception
@@ -6826,7 +7124,6 @@ .locals init (int V_0,
     // sequence point: <hidden>
     IL_0021:  ldloc.1
     IL_0022:  brtrue.s   IL_0011
-    // sequence point: <hidden>
     IL_0024:  leave.s    IL_003e
   }
   catch System.Exception
@@ -6918,7 +7215,6 @@ .locals init (int V_0,
     // sequence point: <hidden>
     IL_0031:  ldloc.2
     IL_0032:  brtrue.s   IL_0011
-    // sequence point: <hidden>
     IL_0034:  leave.s    IL_004e
   }
   catch System.Exception
@@ -7013,7 +7309,6 @@ .locals init (int V_0,
     // sequence point: <hidden>
     IL_003b:  ldloc.2
     IL_003c:  brtrue.s   IL_001b
-    // sequence point: <hidden>
     IL_003e:  leave.s    IL_0058
   }
   catch System.Exception
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBTupleTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBTupleTests.cs
index 2a9cb23531aef..a394b9160e9b6 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBTupleTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBTupleTests.cs
@@ -251,6 +251,7 @@ static void F(System.Collections.Generic.IEnumerable<(int a, int b)> ie)
         <entry offset=""0x21"" startLine=""10"" startColumn=""9"" endLine=""10"" endColumn=""10"" />
         <entry offset=""0x22"" startLine=""7"" startColumn=""13"" endLine=""7"" endColumn=""15"" />
         <entry offset=""0x2c"" hidden=""true"" />
+        <entry offset=""0x36"" hidden=""true"" />
         <entry offset=""0x37"" startLine=""11"" startColumn=""5"" endLine=""11"" endColumn=""6"" />
       </sequencePoints>
       <scope startOffset=""0x0"" endOffset=""0x38"">
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBUsingTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBUsingTests.cs
index 1b563f9ad1b54..61a8b5b5e53bf 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBUsingTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBUsingTests.cs
@@ -1734,7 +1734,7 @@ .locals init (Test V_0)
     IL_000e:  ldloc.0
     IL_000f:  callvirt   ""void System.IDisposable.Dispose()""
     IL_0014:  nop
-    IL_0015:  endfinally
+   ~IL_0015:  endfinally
   }
  -IL_0016:  ret
 }", sequencePoints: "Test.Main");

From 22a15c0b6a30b9989fb3aac98e1123a7d045ba46 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Wed, 17 May 2017 15:22:35 -0700
Subject: [PATCH 277/284] More refactoring

---
 .../LocalRewriter/LocalRewriter_Call.cs       | 57 +++++++++----------
 1 file changed, 27 insertions(+), 30 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index 65f80c694c8a8..38463182dbd62 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -515,36 +515,21 @@ internal static ImmutableArray<IArgument> MakeArgumentsInEvaluationOrder(
             //
             // If neither of those are the case then we can just take an early out.
 
-            ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters(); 
-
-            ArrayBuilder<IArgument> argumentsInEvaluationBuilder = ArrayBuilder<IArgument>.GetInstance(parameters.Length);
 
             if (CanSkipRewriting(arguments, methodOrIndexer, expanded, argsToParamsOpt, invokedAsExtensionMethod, out var isComReceiver))
-            {
+            {                                                                                  
                 // In this case, the invocation is not in expanded form and there's no named argument provided.
-                // So we just return list of arguments as is.   
-                for (int i = 0; i < arguments.Length; i++)
-                {                                                 
-                    argumentsInEvaluationBuilder.Add(BoundCall.CreateArgumentOperation(ArgumentKind.Explicit, parameters[i], arguments[i]));
-                } 
-                return argumentsInEvaluationBuilder.ToImmutableAndFree();
+                // So we just return list of arguments as is.
+                return arguments.ZipAsArray(methodOrIndexer.GetParameters(), (a, p) => BoundCall.CreateArgumentOperation(ArgumentKind.Explicit, p, a));
             }                                                                                                                   
 
-            ArrayBuilder<ParameterSymbol> missingParametersBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameters.Length);
-
-            BuildExplicitArgumentsInEvaluationOrder(syntax, 
-                methodOrIndexer, 
+            return BuildArgumentsInEvaluationOrder(syntax, 
+                methodOrIndexer,
+                optionalParametersMethod,
                 expanded, 
                 argsToParamsOpt, 
                 arguments, 
-                binder, 
-                argumentsInEvaluationBuilder, 
-                missingParametersBuilder);
-
-            AppendMissingOptionalArguments(syntax, methodOrIndexer, optionalParametersMethod, expanded, binder, missingParametersBuilder, argumentsInEvaluationBuilder);
-            missingParametersBuilder.Free();
-
-            return argumentsInEvaluationBuilder.ToImmutableAndFree();
+                binder); 
         }
 
         // temporariesBuilder will be null when factory is null.
@@ -657,19 +642,22 @@ private void BuildStoresToTemps(
         }
 
         // This fills in the arguments and parameters arrays in evaluation order.
-        private static void BuildExplicitArgumentsInEvaluationOrder(
+        private static ImmutableArray<IArgument> BuildArgumentsInEvaluationOrder(
             SyntaxNode syntax,
             Symbol methodOrIndexer,
+            MethodSymbol optionalParametersMethod,
             bool expanded,
             ImmutableArray<int> argsToParamsOpt,
             ImmutableArray<BoundExpression> arguments,
-            Binder binder,
-            /* out */ ArrayBuilder<IArgument> argumentsBuilder,
-            /* out */ ArrayBuilder<ParameterSymbol> missingParametersBuilder)
+            Binder binder)
         {
             ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters();
+
+            ArrayBuilder<IArgument> argumentsInEvaluationBuilder = ArrayBuilder<IArgument>.GetInstance(parameters.Length);
+
             PooledHashSet<int> processedParameters = PooledHashSet<int>.GetInstance();
 
+            // First, fill in all the explicitly provided arguments.
             for (int a = 0; a < arguments.Length; ++a)
             {
                 BoundExpression argument = arguments[a];
@@ -700,12 +688,13 @@ private static void BuildExplicitArgumentsInEvaluationOrder(
                     a = firstNonParamArrayArgumentIndex - 1;
 
                     argument = CreateParamArrayArgument(syntax, parameter.Type, paramArray.ToImmutableAndFree(), null, binder);
-                }  
+                }
 
-                argumentsBuilder.Add(BoundCall.CreateArgumentOperation(kind, parameter, argument)); 
-            }
+                argumentsInEvaluationBuilder.Add(BoundCall.CreateArgumentOperation(kind, parameter, argument)); 
+            }    
 
-            // Fill in parameters with missing arguments.
+            // Collect parameters with missing arguments.   
+            ArrayBuilder<ParameterSymbol> missingParametersBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameters.Length);
             for (int i = 0; i < parameters.Length; ++i)
             {
                 if (!processedParameters.Contains(i))
@@ -713,7 +702,15 @@ private static void BuildExplicitArgumentsInEvaluationOrder(
                     missingParametersBuilder.Add(parameters[i]);
                 }
             }
+
             processedParameters.Free();
+
+            // Finally, append default value as arguments.
+            AppendMissingOptionalArguments(syntax, methodOrIndexer, optionalParametersMethod, expanded, binder, missingParametersBuilder, argumentsInEvaluationBuilder);
+
+            missingParametersBuilder.Free();
+
+            return argumentsInEvaluationBuilder.ToImmutableAndFree();
         }
 
         /// <summary>

From ac6e7c9073486a9dc4861b53f9f50666c6f8e402 Mon Sep 17 00:00:00 2001
From: Gen Lu <gen.lu@microsoft.com>
Date: Wed, 17 May 2017 15:36:42 -0700
Subject: [PATCH 278/284] Minor change in tests

---
 .../IOperation/IOperationTests_IArgument.cs       | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
index f806d06f450b7..9ead4d1738943 100644
--- a/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
+++ b/src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IArgument.cs
@@ -1673,11 +1673,16 @@ public void M2()
         }
 
         private class IndexerAccessArgumentVerifier : OperationWalker
-        {        
-            public static void Verify(IOperation operation)
+        {
+            public static readonly IndexerAccessArgumentVerifier Instance = new IndexerAccessArgumentVerifier();
+
+            private IndexerAccessArgumentVerifier()
             {
-                var walker = new IndexerAccessArgumentVerifier();
-                walker.Visit(operation);             
+            }
+
+            public static void Verify(IOperation operation)
+            {                                                   
+                Instance.Visit(operation);             
             }
 
             public override void VisitIndexedPropertyReferenceExpression(IIndexedPropertyReferenceExpression operation)
@@ -1693,7 +1698,7 @@ public override void VisitIndexedPropertyReferenceExpression(IIndexedPropertyRef
                 {
                     if (!argument.IsInvalid)
                     {
-                        Assert.True(argument.Parameter.ContainingSymbol == indexerSymbol);
+                        Assert.Same(indexerSymbol, argument.Parameter.ContainingSymbol);
                     }
                 }
             }

From a0ec732370b53c22327b74e31994563aa779f430 Mon Sep 17 00:00:00 2001
From: "Brett V. Forsgren" <brettfo@microsoft.com>
Date: Tue, 16 May 2017 13:53:08 -0700
Subject: [PATCH 279/284] bypass command line argument passing if no command
 line parser is available

---
 .../ProjectSystem/AbstractProject_Options.cs  | 24 ++++++++++++-------
 .../CPSProject_IWorkspaceProjectContext.cs    | 10 ++++----
 2 files changed, 21 insertions(+), 13 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/AbstractProject_Options.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/AbstractProject_Options.cs
index 74fd879a24937..99dd794a10138 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/AbstractProject_Options.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/AbstractProject_Options.cs
@@ -11,6 +11,8 @@ internal abstract partial class AbstractProject
     {
         #region Options
         private string _lastParsedCompilerOptions;
+
+        /// Can be null if there is no <see cref="CommandLineParserService" /> available.
         private CommandLineArguments _lastParsedCommandLineArguments;
         private CompilationOptions _currentCompilationOptions;
         private ParseOptions _currentParseOptions;
@@ -47,23 +49,27 @@ private void SetArgumentsCore(string commandLine, CommandLineArguments commandLi
         #endregion
 
         /// <summary>
-        /// Creates and sets new options using the last parsed command line arguments.
+        /// Creates and sets new options using the last parsed command line arguments.  In the case that the last
+        /// parsed options are <see langword="null"/> then this call is a NOP.
         /// </summary>
         protected void UpdateOptions()
         {
             AssertIsForeground();
 
             CommandLineArguments lastParsedCommandLineArguments = _lastParsedCommandLineArguments;
-            Contract.ThrowIfNull(lastParsedCommandLineArguments);
-
-            var newParseOptions = CreateParseOptions(lastParsedCommandLineArguments);
-            var newCompilationOptions = CreateCompilationOptions(lastParsedCommandLineArguments, newParseOptions);
-            if (newCompilationOptions == CurrentCompilationOptions && newParseOptions == CurrentParseOptions)
+            if (lastParsedCommandLineArguments != null)
             {
-                return;
+                // do nothing if the last parsed arguments aren't present, which is the case for languages that don't
+                // export an ICommandLineParserService like F#
+                var newParseOptions = CreateParseOptions(lastParsedCommandLineArguments);
+                var newCompilationOptions = CreateCompilationOptions(lastParsedCommandLineArguments, newParseOptions);
+                if (newCompilationOptions == CurrentCompilationOptions && newParseOptions == CurrentParseOptions)
+                {
+                    return;
+                }
+
+                SetOptions(newCompilationOptions, newParseOptions);
             }
-
-            SetOptions(newCompilationOptions, newParseOptions);
         }
 
         /// <summary>
diff --git a/src/VisualStudio/Core/Impl/ProjectSystem/CPS/CPSProject_IWorkspaceProjectContext.cs b/src/VisualStudio/Core/Impl/ProjectSystem/CPS/CPSProject_IWorkspaceProjectContext.cs
index 5c73518a1bd9a..bcf5111fd657b 100644
--- a/src/VisualStudio/Core/Impl/ProjectSystem/CPS/CPSProject_IWorkspaceProjectContext.cs
+++ b/src/VisualStudio/Core/Impl/ProjectSystem/CPS/CPSProject_IWorkspaceProjectContext.cs
@@ -120,10 +120,12 @@ public void SetOptions(string commandLineForOptions)
             ExecuteForegroundAction(() =>
             {
                 var commandLineArguments = SetArgumentsAndUpdateOptions(commandLineForOptions);
-
-                SetRuleSetFile(commandLineArguments.RuleSetPath);
-
-                PostSetOptions(commandLineArguments);
+                if (commandLineArguments != null)
+                {
+                    // some languages (e.g., F#) don't expose a command line parser and this might be `null`
+                    SetRuleSetFile(commandLineArguments.RuleSetPath);
+                    PostSetOptions(commandLineArguments);
+                }
             });
         }
 

From 8bc010c06e39d541a1ce7f3fa4f03346072930e8 Mon Sep 17 00:00:00 2001
From: elijah6 <elijah.rla@gmail.com>
Date: Thu, 18 May 2017 19:30:41 +0100
Subject: [PATCH 280/284] Skip unreachable catch clauses with constant false
 filter (#19294)

---
 .../LocalRewriter_TryStatement.cs             |   5 +
 .../Test/Emit/CodeGen/CodeGenTryFinally.cs    | 275 ++++++++++++++++++
 .../Semantics/TargetTypedDefaultTests.cs      |  54 +++-
 3 files changed, 330 insertions(+), 4 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TryStatement.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TryStatement.cs
index be1e749b9f2c2..c9b43e9e35a11 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TryStatement.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TryStatement.cs
@@ -79,6 +79,11 @@ public override BoundNode VisitCatchBlock(BoundCatchBlock node)
                 return base.VisitCatchBlock(node);
             }
 
+            if (node.ExceptionFilterOpt.ConstantValue?.BooleanValue == false)
+            {
+                return null;
+            }
+
             BoundExpression rewrittenExceptionSourceOpt = (BoundExpression)this.Visit(node.ExceptionSourceOpt);
             BoundExpression rewrittenFilter = (BoundExpression)this.Visit(node.ExceptionFilterOpt);
             BoundBlock rewrittenBody = (BoundBlock)this.Visit(node.Body);
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTryFinally.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTryFinally.cs
index 57b7dd3f995d6..02b7133564480 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTryFinally.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTryFinally.cs
@@ -2442,6 +2442,281 @@ .locals init (int V_0) //x
 ");
         }
 
+        [WorkItem(18678, "https://github.com/dotnet/roslyn/issues/18678")]
+        [Fact]
+        public void TryCatchConstantFalseFilter1()
+        {
+            var src = @"
+using System;
+class C
+{
+    static void Main()
+    {
+        try
+        {
+            throw new Exception();
+        }
+        catch (Exception) when (false)
+        {
+            Console.Write(""Catch"");
+        }
+    }
+}";
+            var comp = CompileAndVerify(src);
+            comp.VerifyIL("C.Main", @"
+{
+  // Code size        6 (0x6)
+  .maxstack  1
+  IL_0000:  newobj     ""System.Exception..ctor()""
+  IL_0005:  throw
+}");
+        }
+
+        [WorkItem(18678, "https://github.com/dotnet/roslyn/issues/18678")]
+        [Fact]
+        public void TryCatchConstantFalseFilter2()
+        {
+            var src = @"
+using System;
+class C
+{
+    static void Main()
+    {
+        try
+        {
+            throw new Exception();
+        }
+        catch (NullReferenceException) when (false)
+        {
+            Console.Write(""Catch1"");
+        }
+        catch (Exception) when (false)
+        {
+            Console.Write(""Catch2"");
+        }
+        catch when (false)
+        {
+            Console.Write(""Catch"");
+        }
+    }
+}";
+            var comp = CompileAndVerify(src);
+            comp.VerifyIL("C.Main", @"
+{
+  // Code size        6 (0x6)
+  .maxstack  1
+  IL_0000:  newobj     ""System.Exception..ctor()""
+  IL_0005:  throw
+}");
+        }
+
+        [WorkItem(18678, "https://github.com/dotnet/roslyn/issues/18678")]
+        [Fact]
+        public void TryCatchConstantFalseFilter3()
+        {
+            var src = @"
+using System;
+class C
+{
+    static void Main()
+    {
+        try
+        {
+            throw new Exception();
+        }
+        catch (NullReferenceException) when ((1+1) == 2)
+        {
+            Console.Write(""Catch1"");
+        }
+        catch (Exception) when (true == false)
+        {
+            Console.Write(""Catch2"");
+        }
+        catch when ((1+1) != 2)
+        {
+            Console.Write(""Catch"");
+        }
+    }
+}";
+            var comp = CompileAndVerify(src);
+            comp.VerifyIL("C.Main", @"
+{
+  // Code size       39 (0x27)
+  .maxstack  2
+  .try
+  {
+    IL_0000:  newobj     ""System.Exception..ctor()""
+    IL_0005:  throw
+  }
+  filter
+  {
+    IL_0006:  isinst     ""System.NullReferenceException""
+    IL_000b:  dup
+    IL_000c:  brtrue.s   IL_0012
+    IL_000e:  pop
+    IL_000f:  ldc.i4.0
+    IL_0010:  br.s       IL_0017
+    IL_0012:  pop
+    IL_0013:  ldc.i4.1
+    IL_0014:  ldc.i4.0
+    IL_0015:  cgt.un
+    IL_0017:  endfilter
+  }  // end filter
+  {  // handler
+    IL_0019:  pop
+    IL_001a:  ldstr      ""Catch1""
+    IL_001f:  call       ""void System.Console.Write(string)""
+    IL_0024:  leave.s    IL_0026
+  }
+  IL_0026:  ret
+}");
+        }
+
+        [WorkItem(18678, "https://github.com/dotnet/roslyn/issues/18678")]
+        [Fact]
+        public void TryCatchConstantFalseFilterCombined()
+        {
+            var src = @"
+using System;
+class C
+{
+    static void Main()
+    {
+        var message = ""ExceptionMessage"";
+        try
+        {
+            throw new Exception(message);
+        }
+        catch (NullReferenceException) when (false)
+        {
+            Console.Write(""NullReferenceCatch"");
+        }
+        catch (Exception e) when (e.Message == message)
+        {
+            Console.Write(""ExceptionFilter"");
+        }
+        catch (Exception)
+        {
+            Console.Write(""ExceptionCatch"");
+        }
+        catch when (false)
+        {
+            Console.Write(""Catch"");
+        }
+    }
+}";
+            var comp = CompileAndVerify(src, expectedOutput: "ExceptionFilter");
+            comp.VerifyIL("C.Main", @"
+{
+  // Code size       68 (0x44)
+  .maxstack  2
+  .locals init (string V_0) //message
+  IL_0000:  ldstr      ""ExceptionMessage""
+  IL_0005:  stloc.0
+  .try
+  {
+    IL_0006:  ldloc.0
+    IL_0007:  newobj     ""System.Exception..ctor(string)""
+    IL_000c:  throw
+  }
+  filter
+  {
+    IL_000d:  isinst     ""System.Exception""
+    IL_0012:  dup
+    IL_0013:  brtrue.s   IL_0019
+    IL_0015:  pop
+    IL_0016:  ldc.i4.0
+    IL_0017:  br.s       IL_0027
+    IL_0019:  callvirt   ""string System.Exception.Message.get""
+    IL_001e:  ldloc.0
+    IL_001f:  call       ""bool string.op_Equality(string, string)""
+    IL_0024:  ldc.i4.0
+    IL_0025:  cgt.un
+    IL_0027:  endfilter
+  }  // end filter
+  {  // handler
+    IL_0029:  pop
+    IL_002a:  ldstr      ""ExceptionFilter""
+    IL_002f:  call       ""void System.Console.Write(string)""
+    IL_0034:  leave.s    IL_0043
+  }
+  catch System.Exception
+  {
+    IL_0036:  pop
+    IL_0037:  ldstr      ""ExceptionCatch""
+    IL_003c:  call       ""void System.Console.Write(string)""
+    IL_0041:  leave.s    IL_0043
+  }
+  IL_0043:  ret
+}");
+        }
+
+        [WorkItem(18678, "https://github.com/dotnet/roslyn/issues/18678")]
+        [Fact]
+        public void TryCatchFinallyConstantFalseFilter()
+        {
+            var src = @"
+using System;
+class C
+{
+    static void Main()
+    {
+        try
+        {
+
+            try
+            {
+                throw new Exception();
+            }
+            catch (NullReferenceException) when (false)
+            {
+                Console.Write(""Catch1"");
+            }
+            catch (Exception) when (false)
+            {
+                Console.Write(""Catch2"");
+            }
+            finally
+            {
+                Console.Write(""Finally"");
+            }
+        }
+        catch
+        {
+            Console.Write(""OuterCatch"");
+        }
+    }
+}";
+            var comp = CompileAndVerify(src, expectedOutput: "FinallyOuterCatch");
+            comp.VerifyIL("C.Main", @"
+{
+  // Code size       31 (0x1f)
+  .maxstack  1
+  .try
+  {
+    .try
+    {
+      IL_0000:  newobj     ""System.Exception..ctor()""
+      IL_0005:  throw
+    }
+    finally
+    {
+      IL_0006:  ldstr      ""Finally""
+      IL_000b:  call       ""void System.Console.Write(string)""
+      IL_0010:  endfinally
+    }
+  }
+  catch object
+  {
+    IL_0011:  pop
+    IL_0012:  ldstr      ""OuterCatch""
+    IL_0017:  call       ""void System.Console.Write(string)""
+    IL_001c:  leave.s    IL_001e
+  }
+  IL_001e:  ret
+}");
+        }
+
         [Fact]
         public void TryCatchWithReturnValue()
         {
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/TargetTypedDefaultTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/TargetTypedDefaultTests.cs
index b73c38922472a..d45d6a6c4fb23 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/TargetTypedDefaultTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/TargetTypedDefaultTests.cs
@@ -853,7 +853,7 @@ static void Main()
         }
 
         [Fact]
-        public void PEVerifyErrorWithFalse()
+        public void PEVerifyWithUnreachableCatch1()
         {
             string source = @"
 class C
@@ -864,7 +864,7 @@ static void Main()
         {
             throw new System.Exception();
         }
-        catch (System.Exception) when (false)
+        catch (System.Exception) when (default)
         {
             System.Console.Write(""catch"");
         }
@@ -875,12 +875,58 @@ static void Main()
             comp.VerifyDiagnostics(
                 // (10,40): warning CS7095: Filter expression is a constant, consider removing the filter
                 //         catch (System.Exception) when (false)
-                Diagnostic(ErrorCode.WRN_FilterIsConstant, "false").WithLocation(10, 40),
+                Diagnostic(ErrorCode.WRN_FilterIsConstant, "default").WithLocation(10, 40),
                 // (12,13): warning CS0162: Unreachable code detected
                 //             System.Console.Write("catch");
                 Diagnostic(ErrorCode.WRN_UnreachableCode, "System").WithLocation(12, 13)
                 );
-            //CompileAndVerify(comp); // PEVerify failed with Branch out of the method. Follow-up issue: https://github.com/dotnet/roslyn/issues/18678
+            CompileAndVerify(comp);
+        }
+
+        [Fact]
+        public void PEVerifyWithUnreachableCatch2()
+        {
+            string source = @"
+class C
+{
+    static void Main()
+    {
+        try
+        {
+            SomeAction();
+        }
+        catch (System.NullReferenceException)
+        {
+            System.Console.Write(""NullReferenceException"");
+        }
+        catch
+        {
+            System.Console.Write(""OtherExceptions"");
+        }
+    }
+
+    private static void SomeAction()
+    {
+        try
+        {
+            throw new System.NullReferenceException();
+        }
+        catch (System.Exception) when (default)
+        {
+            System.Console.Write(""Unreachable"");
+        }
+    }
+}";
+            var comp = CreateStandardCompilation(source, parseOptions: TestOptions.Regular7_1, options: TestOptions.DebugExe);
+            comp.VerifyDiagnostics(
+                // (26,40): warning CS7095: Filter expression is a constant, consider removing the filter
+                //         catch (System.Exception) when (false)
+                Diagnostic(ErrorCode.WRN_FilterIsConstant, "default").WithLocation(26, 40),
+                // (28,13): warning CS0162: Unreachable code detected
+                //             System.Console.Write("catch");
+                Diagnostic(ErrorCode.WRN_UnreachableCode, "System").WithLocation(28, 13)
+                );
+            CompileAndVerify(comp, expectedOutput: "NullReferenceException");
         }
 
         [Fact]

From b66f68c485fb1c6bbfa69c62490ff47d37d5dae5 Mon Sep 17 00:00:00 2001
From: Jared Parsons <jaredpar@microsoft.com>
Date: Wed, 17 May 2017 12:34:17 -0700
Subject: [PATCH 281/284] Emitted pdb path should respect PathMap

The PDB path which is written into the PE file should respect the
`/pathmap` option passed to the compiler.  This is necessary to ensure
that PEs can be deterministic when built from different source paths.

The feature flag `pdb-path-determinism` is being kept for the time
being.  Even though it's a feature flag it still seems inappropriate to
break customers in a point release.  Deferring the removal until the
next major release to give customers time to react.  This issue tracks
removing the flag:

https://github.com/dotnet/roslyn/issues/19592

closes #9813
---
 build/scripts/test-determinism.ps1            |  2 +-
 .../Test/CommandLine/CommandLineTests.cs      | 79 ++++++++++++++++++-
 .../Test/Emit/Emit/DeterministicTests.cs      |  1 +
 .../CommandLine/CommonCommandLineArguments.cs |  1 +
 .../Portable/CommandLine/CommonCompiler.cs    | 16 ++--
 .../Core/Portable/Compilation/Compilation.cs  | 31 +++-----
 .../Core/Portable/FileSystem/PathUtilities.cs | 36 +++++++++
 .../Core/Portable/SourceFileResolver.cs       | 38 +--------
 .../Test/CommandLine/CommandLineTests.vb      | 68 ++++++++++++++++
 .../Portable/Traits/CompilerFeature.cs        |  1 +
 10 files changed, 206 insertions(+), 67 deletions(-)

diff --git a/build/scripts/test-determinism.ps1 b/build/scripts/test-determinism.ps1
index 74f497ebe9e65..c087c9510729a 100644
--- a/build/scripts/test-determinism.ps1
+++ b/build/scripts/test-determinism.ps1
@@ -46,7 +46,7 @@ function Run-Build() {
         }
 
         Write-Host "Building the Solution"
-        Exec-Command $msbuild "/nologo /v:m /nodeReuse:false /m /p:DebugDeterminism=true /p:BootstrapBuildPath=$script:bootstrapDir /p:Features=`"debug-determinism;pdb-path-determinism`" /p:UseRoslynAnalyzers=false $pathMapBuildOption $sln"
+        Exec-Command $msbuild "/nologo /v:m /nodeReuse:false /m /p:DebugDeterminism=true /p:BootstrapBuildPath=$script:bootstrapDir /p:Features=`"debug-determinism`" /p:UseRoslynAnalyzers=false $pathMapBuildOption $sln"
     }
     finally {
         Pop-Location
diff --git a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
index 093b1192ab2f4..a3d3b87784e2e 100644
--- a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
+++ b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
@@ -36,7 +36,7 @@ public class CommandLineTests : CSharpTestBase
         private static readonly string s_defaultSdkDirectory = RuntimeEnvironment.GetRuntimeDirectory();
         private static readonly string s_compilerVersion = typeof(Csc).GetTypeInfo().Assembly.GetCustomAttribute<AssemblyFileVersionAttribute>().Version;
         private static readonly string s_compilerShortCommitHash =
-            CommonCompiler.ExtractShortCommitHash(typeof(CSharpCompiler).GetTypeInfo().Assembly.GetCustomAttribute<CommitHashAttribute>().Hash);
+            CommonCompiler.ExtractShortCommitHash(typeof(CSharpCompiler).GetTypeInfo().Assembly.GetCustomAttribute<CommitHashAttribute>()?.Hash);
 
         private readonly string _baseDirectory = TempRoot.Root;
 
@@ -9030,6 +9030,7 @@ public void ParseSeparatedPaths_QuotedComma()
                 paths);
         }
 
+        [CompilerTrait(CompilerFeature.Determinism)]
         [Fact]
         public void PathMapParser()
         {
@@ -9063,6 +9064,82 @@ public void PathMapParser()
             Assert.Equal((int)ErrorCode.ERR_InvalidPathMap, parsedArgs.Errors[0].Code);
         }
 
+        [Fact]
+        [CompilerTrait(CompilerFeature.Determinism)]
+        public void PathMapPdbParser()
+        {
+            var dir = Path.Combine(_baseDirectory, "a");
+            var parsedArgs = DefaultParse(new[] { $@"/pathmap:{dir}=b:\", "a.cs", @"/pdb:a\data.pdb", "/debug:full" }, _baseDirectory);
+            parsedArgs.Errors.Verify();
+            Assert.Equal(Path.Combine(dir, @"data.pdb"), parsedArgs.PdbPath);
+
+            // This value is calculate during Emit phases and should be null even in the face of a pathmap targeting it.
+            Assert.Null(parsedArgs.EmitOptions.PdbFilePath);
+        }
+
+        [Fact]
+        [CompilerTrait(CompilerFeature.Determinism)]
+        public void PathMapPdbEmit()
+        {
+            void AssertPdbEmit(TempDirectory dir, string pdbPath, string pePdbPath, params string[] extraArgs)
+            {
+                var source = @"class Program { static void Main() { } }";
+                var src = dir.CreateFile("a.cs").WriteAllText(source);
+                var defaultArgs = new[] { "/nologo", "a.cs", "/out:a.exe", "/debug:full", $"/pdb:{pdbPath}" };
+                var isDeterministic = extraArgs.Contains("/deterministic");
+                var args = defaultArgs.Concat(extraArgs).ToArray();
+                var outWriter = new StringWriter(CultureInfo.InvariantCulture);
+
+                var csc = new MockCSharpCompiler(null, dir.Path, args);
+                int exitCode = csc.Run(outWriter);
+                Assert.Equal(0, exitCode);
+
+                var exePath = Path.Combine(dir.Path, "a.exe");
+                Assert.True(File.Exists(exePath));
+                Assert.True(File.Exists(pdbPath));
+                using (var peStream = File.OpenRead(exePath))
+                {
+                    PdbValidation.ValidateDebugDirectory(peStream, null, pePdbPath, isDeterministic);
+                }
+            }
+
+            // Case with no mappings
+            using (var dir = new DisposableDirectory(Temp))
+            {
+                var pdbPath = Path.Combine(dir.Path, "a.pdb");
+                AssertPdbEmit(dir, pdbPath, pdbPath);
+            }
+
+            // Simple mapping
+            using (var dir = new DisposableDirectory(Temp))
+            {
+                var pdbPath = Path.Combine(dir.Path, "a.pdb");
+                AssertPdbEmit(dir, pdbPath, @"q:\a.pdb", $@"/pathmap:{dir.Path}=q:\");
+            }
+
+            // Simple mapping deterministic
+            using (var dir = new DisposableDirectory(Temp))
+            {
+                var pdbPath = Path.Combine(dir.Path, "a.pdb");
+                AssertPdbEmit(dir, pdbPath, @"q:\a.pdb", $@"/pathmap:{dir.Path}=q:\", "/deterministic");
+            }
+
+            // Partial mapping
+            using (var dir = new DisposableDirectory(Temp))
+            {
+                dir.CreateDirectory("pdb");
+                var pdbPath = Path.Combine(dir.Path, @"pdb\a.pdb");
+                AssertPdbEmit(dir, pdbPath, @"q:\pdb\a.pdb", $@"/pathmap:{dir.Path}=q:\");
+            }
+
+            // Legacy feature flag
+            using (var dir = new DisposableDirectory(Temp))
+            {
+                var pdbPath = Path.Combine(dir.Path, "a.pdb");
+                AssertPdbEmit(dir, pdbPath, @"a.pdb", $@"/features:pdb-path-determinism");
+            }
+        }
+
         [WorkItem(7588, "https://github.com/dotnet/roslyn/issues/7588")]
         [Fact]
         public void Version()
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/DeterministicTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/DeterministicTests.cs
index a3a6be5cbb7b4..b393d6bff2fbd 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/DeterministicTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/DeterministicTests.cs
@@ -15,6 +15,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Emit
 {
+    [CompilerTrait(CompilerFeature.Determinism)]
     public class DeterministicTests : EmitMetadataTestBase
     {
         private Guid CompiledGuid(string source, string assemblyName, bool debug)
diff --git a/src/Compilers/Core/Portable/CommandLine/CommonCommandLineArguments.cs b/src/Compilers/Core/Portable/CommandLine/CommonCommandLineArguments.cs
index 1202e4527b9c4..8fc9437af0378 100644
--- a/src/Compilers/Core/Portable/CommandLine/CommonCommandLineArguments.cs
+++ b/src/Compilers/Core/Portable/CommandLine/CommonCommandLineArguments.cs
@@ -468,5 +468,6 @@ private AnalyzerFileReference ResolveAnalyzerReference(CommandLineAnalyzerRefere
             return null;
         }
         #endregion
+
     }
 }
diff --git a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
index 48d6cb87adf90..b40d4d7c77155 100644
--- a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
+++ b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
@@ -606,16 +606,10 @@ private int RunCore(TextWriter consoleOutput, ErrorLogger errorLogger, Cancellat
                     // NOTE: Unlike the PDB path, the XML doc path is not embedded in the assembly, so we don't need to pass it to emit.
                     var emitOptions = Arguments.EmitOptions.
                         WithOutputNameOverride(outputName).
-                        WithPdbFilePath(finalPdbFilePath);
-
-                    // The PDB path is emitted in it's entirety into the PE.  This makes it impossible to have deterministic
-                    // builds that occur in different source directories.  To enable this we shave all path information from
-                    // the PDB when specified by the user.  
-                    //
-                    // This is a temporary work around to allow us to make progress with determinism.  The following issue 
-                    // tracks getting an official solution here.
-                    //
-                    // https://github.com/dotnet/roslyn/issues/9813
+                        WithPdbFilePath(PathUtilities.NormalizePathPrefix(finalPdbFilePath, Arguments.PathMap));
+
+                    // This feature flag is being maintained until our next major release to avoid unnecessary 
+                    // compat breaks with customers.
                     if (Arguments.ParseOptions.Features.ContainsKey("pdb-path-determinism") && !string.IsNullOrEmpty(emitOptions.PdbFilePath))
                     {
                         emitOptions = emitOptions.WithPdbFilePath(Path.GetFileName(emitOptions.PdbFilePath));
@@ -766,7 +760,7 @@ private int RunCore(TextWriter consoleOutput, ErrorLogger errorLogger, Cancellat
                                     metadataOnly: emitOptions.EmitMetadataOnly,
                                     includePrivateMembers: emitOptions.IncludePrivateMembers,
                                     emitTestCoverageData: emitOptions.EmitTestCoverageData,
-                                    pdbFilePath: emitOptions.PdbFilePath,
+                                    pePdbFilePath: emitOptions.PdbFilePath,
                                     cancellationToken: cancellationToken);
                             }
                             finally
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index aa8ebb9a90045..3d755d19ebea6 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -2228,7 +2228,7 @@ internal EmitResult Emit(
                         metadataOnly: options.EmitMetadataOnly,
                         includePrivateMembers: options.IncludePrivateMembers,
                         emitTestCoverageData: options.EmitTestCoverageData,
-                        pdbFilePath: options.PdbFilePath,
+                        pePdbFilePath: options.PdbFilePath,
                         cancellationToken: cancellationToken);
                 }
             }
@@ -2391,7 +2391,7 @@ internal bool SerializeToPeStream(
             bool metadataOnly,
             bool includePrivateMembers,
             bool emitTestCoverageData,
-            string pdbFilePath,
+            string pePdbFilePath,
             CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -2409,20 +2409,15 @@ internal bool SerializeToPeStream(
             // PDB Stream provider should not be given if PDB is to be embedded into the PE file:
             Debug.Assert(moduleBeingBuilt.DebugInformationFormat != DebugInformationFormat.Embedded || pdbStreamProvider == null);
 
-            string pdbPath = (pdbStreamProvider != null || moduleBeingBuilt.DebugInformationFormat == DebugInformationFormat.Embedded) ?
-                (pdbFilePath ?? FileNameUtilities.ChangeExtension(SourceModule.Name, "pdb")) : null;
-
-            // The PDB path is emitted in it's entirety into the PE.  This makes it impossible to have deterministic
-            // builds that occur in different source directories.  To enable this we shave all path information from
-            // the PDB when specified by the user.  
-            //
-            // This is a temporary work around to allow us to make progress with determinism.  The following issue 
-            // tracks getting an official solution here.
-            //
-            // https://github.com/dotnet/roslyn/issues/9813
-            string pePdbPath = (moduleBeingBuilt.DebugInformationFormat == DebugInformationFormat.Embedded || Feature("pdb-path-determinism") != null) && !string.IsNullOrEmpty(pdbPath)
-                ? Path.GetFileName(pdbPath)
-                : pdbPath;
+            if ((moduleBeingBuilt.DebugInformationFormat == DebugInformationFormat.Embedded || pdbStreamProvider != null))
+            {
+                pePdbFilePath = pePdbFilePath ?? FileNameUtilities.ChangeExtension(SourceModule.Name, "pdb");
+            }
+
+            if (moduleBeingBuilt.DebugInformationFormat == DebugInformationFormat.Embedded && !string.IsNullOrEmpty(pePdbFilePath))
+            {
+                pePdbFilePath = Path.GetFileName(pePdbFilePath);
+            }
 
             try
             {
@@ -2433,7 +2428,7 @@ internal bool SerializeToPeStream(
                     // The calls ISymUnmanagedWriter2.GetDebugInfo require a file name in order to succeed.  This is 
                     // frequently used during PDB writing.  Ensure a name is provided here in the case we were given
                     // only a Stream value.
-                    nativePdbWriter = new Cci.PdbWriter(pdbPath, testSymWriterFactory, deterministic);
+                    nativePdbWriter = new Cci.PdbWriter(pePdbFilePath, testSymWriterFactory, deterministic);
                 }
 
                 Func<Stream> getPortablePdbStream;
@@ -2529,7 +2524,7 @@ internal bool SerializeToPeStream(
                         getRefPeStream,
                         getPortablePdbStream,
                         nativePdbWriter,
-                        pePdbPath,
+                        pePdbFilePath,
                         metadataOnly,
                         includePrivateMembers,
                         deterministic,
diff --git a/src/Compilers/Core/Portable/FileSystem/PathUtilities.cs b/src/Compilers/Core/Portable/FileSystem/PathUtilities.cs
index 489d7ba85b1c8..c7fc9ee8f1c5a 100644
--- a/src/Compilers/Core/Portable/FileSystem/PathUtilities.cs
+++ b/src/Compilers/Core/Portable/FileSystem/PathUtilities.cs
@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
@@ -615,6 +616,41 @@ private static int PathHashCode(string path)
             return hc;
         }
 
+        public static string NormalizePathPrefix(string filePath, ImmutableArray<KeyValuePair<string, string>> pathMap)
+        {
+            if (pathMap.IsDefaultOrEmpty)
+            {
+                return filePath;
+            }
+
+            // find the first key in the path map that matches a prefix of the normalized path (followed by a path separator).
+            // Note that we expect the client to use consistent capitalization; we use ordinal (case-sensitive) comparisons.
+            foreach (var kv in pathMap)
+            {
+                var oldPrefix = kv.Key;
+                if (!(oldPrefix?.Length > 0)) continue;
+
+                if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal) && filePath.Length > oldPrefix.Length && PathUtilities.IsDirectorySeparator(filePath[oldPrefix.Length]))
+                {
+                    var replacementPrefix = kv.Value;
+
+                    // Replace that prefix.
+                    var replacement = replacementPrefix + filePath.Substring(oldPrefix.Length);
+
+                    // Normalize the path separators if used uniformly in the replacement
+                    bool hasSlash = replacementPrefix.IndexOf('/') >= 0;
+                    bool hasBackslash = replacementPrefix.IndexOf('\\') >= 0;
+                    return
+                        (hasSlash && !hasBackslash) ? replacement.Replace('\\', '/') :
+                        (hasBackslash && !hasSlash) ? replacement.Replace('/', '\\') :
+                        replacement;
+                }
+            }
+
+            return filePath;
+        }
+
+
         public static readonly IEqualityComparer<string> Comparer = new PathComparer();
 
         private class PathComparer : IEqualityComparer<string>
diff --git a/src/Compilers/Core/Portable/SourceFileResolver.cs b/src/Compilers/Core/Portable/SourceFileResolver.cs
index d2ca220ab5060..8a5bc05804d3e 100644
--- a/src/Compilers/Core/Portable/SourceFileResolver.cs
+++ b/src/Compilers/Core/Portable/SourceFileResolver.cs
@@ -66,7 +66,7 @@ public SourceFileResolver(
                         throw new ArgumentException(CodeAnalysisResources.NullValueInPathMap, nameof(pathMap));
                     }
 
-                    if (IsPathSeparator(key[key.Length - 1]))
+                    if (PathUtilities.IsDirectorySeparator(key[key.Length - 1]))
                     {
                         throw new ArgumentException(CodeAnalysisResources.KeyInPathMapEndsWithSeparator, nameof(pathMap));
                     }
@@ -83,35 +83,7 @@ public SourceFileResolver(
         public override string NormalizePath(string path, string baseFilePath)
         {
             string normalizedPath = FileUtilities.NormalizeRelativePath(path, baseFilePath, _baseDirectory);
-            return (normalizedPath == null || _pathMap.IsDefaultOrEmpty) ? normalizedPath : NormalizePathPrefix(normalizedPath, _pathMap);
-        }
-
-        private static string NormalizePathPrefix(string normalizedPath, ImmutableArray<KeyValuePair<string, string>> pathMap)
-        {
-            // find the first key in the path map that matches a prefix of the normalized path (followed by a path separator).
-            // Note that we expect the client to use consistent capitalization; we use ordinal (case-sensitive) comparisons.
-            foreach (var kv in pathMap)
-            {
-                var oldPrefix = kv.Key;
-                if (!(oldPrefix?.Length > 0)) continue;
-                if (normalizedPath.StartsWith(oldPrefix, StringComparison.Ordinal) && normalizedPath.Length > oldPrefix.Length && IsPathSeparator(normalizedPath[oldPrefix.Length]))
-                {
-                    var replacementPrefix = kv.Value;
-
-                    // Replace that prefix.
-                    var replacement = replacementPrefix + normalizedPath.Substring(oldPrefix.Length);
-
-                    // Normalize the path separators if used uniformly in the replacement
-                    bool hasSlash = replacementPrefix.IndexOf('/') >= 0;
-                    bool hasBackslash = replacementPrefix.IndexOf('\\') >= 0;
-                    return
-                        (hasSlash && !hasBackslash) ? replacement.Replace('\\', '/') :
-                        (hasBackslash && !hasSlash) ? replacement.Replace('/', '\\') :
-                        replacement;
-                }
-            }
-
-            return normalizedPath;
+            return (normalizedPath == null || _pathMap.IsDefaultOrEmpty) ? normalizedPath : PathUtilities.NormalizePathPrefix(normalizedPath, _pathMap);
         }
 
         public override string ResolveReference(string path, string baseFilePath)
@@ -125,12 +97,6 @@ public override string ResolveReference(string path, string baseFilePath)
             return FileUtilities.TryNormalizeAbsolutePath(resolvedPath);
         }
 
-        // For purposes of command-line processing, allow both \ and / to act as path separators.
-        internal static bool IsPathSeparator(char c)
-        {
-            return (c == '\\') || (c == '/');
-        }
-
         public override Stream OpenRead(string resolvedPath)
         {
             CompilerPathUtilities.RequireAbsolutePath(resolvedPath, nameof(resolvedPath));
diff --git a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
index 9ab1efe92ff5f..a1e9132131e3c 100644
--- a/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
+++ b/src/Compilers/VisualBasic/Test/CommandLine/CommandLineTests.vb
@@ -2887,6 +2887,74 @@ print Goodbye, World"
             CleanupAllGeneratedFiles(src.Path)
         End Sub
 
+        <CompilerTrait(CompilerFeature.Determinism)>
+        <Fact>
+        Public Sub PathMapPdbDeterminism()
+            Dim assertPdbEmit =
+                Sub(dir As TempDirectory, pePdbPath As String, extraArgs As String())
+
+                    Dim source =
+                        <compilation>
+Imports System
+Module Program
+    Sub Main()
+    End Sub
+End Module
+                        </compilation>
+
+                    Dim src = dir.CreateFile("a.vb").WriteAllText(source.Value)
+                    Dim pdbPath = Path.Combine(dir.Path, "a.pdb")
+                    Dim defaultArgs = {"/nologo", "/debug", "a.vb"}
+                    Dim isDeterministic = extraArgs.Contains("/deterministic")
+                    Dim args = defaultArgs.Concat(extraArgs).ToArray()
+                    Dim outWriter = New StringWriter(CultureInfo.InvariantCulture)
+
+                    Dim vbc = New MockVisualBasicCompiler(dir.Path, args)
+                    Dim exitCode = vbc.Run(outWriter)
+                    Assert.Equal(0, exitCode)
+
+                    Dim exePath = Path.Combine(dir.Path, "a.exe")
+                    Assert.True(File.Exists(exePath))
+                    Assert.True(File.Exists(pdbPath))
+
+                    Using peStream = File.OpenRead(exePath)
+                        PdbValidation.ValidateDebugDirectory(peStream, Nothing, pePdbPath, isDeterministic)
+                    End Using
+                End Sub
+
+            ' No mappings
+            Using dir As New DisposableDirectory(Temp)
+                Dim pePdbPath = Path.Combine(dir.Path, "a.pdb")
+                assertPdbEmit(dir, pePdbPath, {})
+            End Using
+
+            ' Simple mapping
+            Using dir As New DisposableDirectory(Temp)
+                Dim pePdbPath = "q:\a.pdb"
+                assertPdbEmit(dir, pePdbPath, {$"/pathmap:{dir.Path}=q:\"})
+            End Using
+
+            ' Simple mapping deterministic
+            Using dir As New DisposableDirectory(Temp)
+                Dim pePdbPath = "q:\a.pdb"
+                assertPdbEmit(dir, pePdbPath, {$"/pathmap:{dir.Path}=q:\", "/deterministic"})
+            End Using
+
+            ' Partial mapping
+            Using dir As New DisposableDirectory(Temp)
+                Dim subDir = dir.CreateDirectory("example")
+                Dim pePdbPath = "q:\example\a.pdb"
+                assertPdbEmit(subDir, pePdbPath, {$"/pathmap:{dir.Path}=q:\"})
+            End Using
+
+            ' Legacy feature flag
+            Using dir As New DisposableDirectory(Temp)
+                Dim pePdbPath = Path.Combine(dir.Path, "a.pdb")
+                assertPdbEmit(dir, "a.pdb", {"/features:pdb-path-determinism"})
+            End Using
+        End Sub
+
+
         <WorkItem(540891, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/540891")>
         <Fact>
         Public Sub ParseOut()
diff --git a/src/Test/Utilities/Portable/Traits/CompilerFeature.cs b/src/Test/Utilities/Portable/Traits/CompilerFeature.cs
index 0530fb6217152..76ff40ae411d9 100644
--- a/src/Test/Utilities/Portable/Traits/CompilerFeature.cs
+++ b/src/Test/Utilities/Portable/Traits/CompilerFeature.cs
@@ -11,6 +11,7 @@ public enum CompilerFeature
         Async,
         Dynamic,
         ExpressionBody,
+        Determinism,
         Iterator,
         LocalFunctions,
         Params,

From 305d62b7f00928676a9348c7b5db3ab6daf2b010 Mon Sep 17 00:00:00 2001
From: Jared Parsons <jaredpar@microsoft.com>
Date: Wed, 17 May 2017 16:36:04 -0700
Subject: [PATCH 282/284] Fix subtle issue around path separators

---
 .../Core/Portable/Compilation/Compilation.cs       |  2 +-
 .../Core/Portable/FileSystem/PathUtilities.cs      | 14 ++++++++------
 src/Compilers/Core/Portable/SourceFileResolver.cs  |  2 +-
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index 3d755d19ebea6..e29aa55a9d416 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -2409,7 +2409,7 @@ internal bool SerializeToPeStream(
             // PDB Stream provider should not be given if PDB is to be embedded into the PE file:
             Debug.Assert(moduleBeingBuilt.DebugInformationFormat != DebugInformationFormat.Embedded || pdbStreamProvider == null);
 
-            if ((moduleBeingBuilt.DebugInformationFormat == DebugInformationFormat.Embedded || pdbStreamProvider != null))
+            if (moduleBeingBuilt.DebugInformationFormat == DebugInformationFormat.Embedded || pdbStreamProvider != null)
             {
                 pePdbFilePath = pePdbFilePath ?? FileNameUtilities.ChangeExtension(SourceModule.Name, "pdb");
             }
diff --git a/src/Compilers/Core/Portable/FileSystem/PathUtilities.cs b/src/Compilers/Core/Portable/FileSystem/PathUtilities.cs
index c7fc9ee8f1c5a..e4f881e38362d 100644
--- a/src/Compilers/Core/Portable/FileSystem/PathUtilities.cs
+++ b/src/Compilers/Core/Portable/FileSystem/PathUtilities.cs
@@ -25,12 +25,14 @@ internal static class PathUtilities
         internal static bool IsUnixLikePlatform => PlatformInformation.IsUnix;
 
         /// <summary>
-        /// True if the character is a directory separator character.
+        /// True if the character is the platform directory separator character or the alternate directory separator.
         /// </summary>
-        public static bool IsDirectorySeparator(char c)
-        {
-            return c == DirectorySeparatorChar || c == AltDirectorySeparatorChar;
-        }
+        public static bool IsDirectorySeparator(char c) => c == DirectorySeparatorChar || c == AltDirectorySeparatorChar;
+
+        /// <summary>
+        /// True if the character is any recognized directory separator character.
+        /// </summary>
+        public static bool IsAnyDirectorySeparator(char c) => c == '\\' || c == '/';
 
         /// <summary>
         /// Removes trailing directory separator characters
@@ -630,7 +632,7 @@ public static string NormalizePathPrefix(string filePath, ImmutableArray<KeyValu
                 var oldPrefix = kv.Key;
                 if (!(oldPrefix?.Length > 0)) continue;
 
-                if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal) && filePath.Length > oldPrefix.Length && PathUtilities.IsDirectorySeparator(filePath[oldPrefix.Length]))
+                if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal) && filePath.Length > oldPrefix.Length && IsAnyDirectorySeparator(filePath[oldPrefix.Length]))
                 {
                     var replacementPrefix = kv.Value;
 
diff --git a/src/Compilers/Core/Portable/SourceFileResolver.cs b/src/Compilers/Core/Portable/SourceFileResolver.cs
index 8a5bc05804d3e..d791f8cfa49d8 100644
--- a/src/Compilers/Core/Portable/SourceFileResolver.cs
+++ b/src/Compilers/Core/Portable/SourceFileResolver.cs
@@ -66,7 +66,7 @@ public SourceFileResolver(
                         throw new ArgumentException(CodeAnalysisResources.NullValueInPathMap, nameof(pathMap));
                     }
 
-                    if (PathUtilities.IsDirectorySeparator(key[key.Length - 1]))
+                    if (PathUtilities.IsAnyDirectorySeparator(key[key.Length - 1]))
                     {
                         throw new ArgumentException(CodeAnalysisResources.KeyInPathMapEndsWithSeparator, nameof(pathMap));
                     }

From 32de942de3675b3bb8060f79ff54e2b2f1626bec Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrusn@microsoft.com>
Date: Thu, 18 May 2017 13:34:28 -0700
Subject: [PATCH 283/284] Disable vsix check.

---
 .../Experimentation/AnalyzerVsixSuggestedActionCallback.cs    | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
index 7b0c355ec6a67..07bb6058bb9d0 100644
--- a/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Experimentation/AnalyzerVsixSuggestedActionCallback.cs
@@ -13,7 +13,8 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.Experimentation
 {
-    [Export(typeof(ISuggestedActionCallback))]
+    // Disabling until https://github.com/dotnet/roslyn/issues/19629 is fixed.
+    // [Export(typeof(ISuggestedActionCallback))]
     internal class AnalyzerVsixSuggestedActionCallback : ForegroundThreadAffinitizedObject, ISuggestedActionCallback
     {
         private const string AnalyzerEnabledFlight = @"LiveCA/LiveCAcf";
@@ -50,6 +51,7 @@ public void OnSuggestedActionExecuted(SuggestedAction action)
             // thread to get it
             AssertIsForeground();
 
+            
             // If the user has previously clicked don't show again, then we bail out immediately
             if (_workspace.Options.GetOption(AnalyzerABTestOptions.NeverShowAgain))
             {

From ba0cefe70bad6c0094a148b033386773243323fa Mon Sep 17 00:00:00 2001
From: Charles Stoner <chucks@microsoft.com>
Date: Thu, 18 May 2017 16:16:16 -0700
Subject: [PATCH 284/284] Include overflow checks in tuple conversions (#19418)

Include overflow checks in tuple conversions
---
 .../Portable/Binder/Binder_Conversions.cs     |  34 +-
 .../LocalRewriter/LocalRewriter_Conversion.cs |  77 +---
 .../Test/Emit/CodeGen/CodeGenCheckedTests.cs  | 411 ++++++++++++++++++
 .../Test/Emit/CodeGen/CodeGenTupleTest.cs     | 135 +++++-
 .../Test/Emit/CodeGen/CodeGenTuples.vb        |  65 +++
 5 files changed, 628 insertions(+), 94 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
index 42648bd0353c2..9a72799ed7212 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
@@ -1,12 +1,11 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Roslyn.Utilities;
-using System.Collections.Immutable;
-using System;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -114,40 +113,13 @@ protected BoundExpression CreateConversion(
                 syntax,
                 source,
                 conversion,
-                IsCheckedConversion(source.Type, destination),
+                @checked: CheckOverflowAtRuntime,
                 explicitCastInCode: isCast && !wasCompilerGenerated,
                 constantValueOpt: constantValue,
                 type: destination)
             { WasCompilerGenerated = wasCompilerGenerated };
         }
 
-        private bool IsCheckedConversion(TypeSymbol source, TypeSymbol target)
-        {
-            Debug.Assert((object)target != null);
-
-            if ((object)source == null || !CheckOverflowAtRuntime)
-            {
-                return false;
-            }
-
-            if (source.IsDynamic())
-            {
-                return true;
-            }
-
-            SpecialType sourceST = source.StrippedType().EnumUnderlyingType().SpecialType;
-            SpecialType targetST = target.StrippedType().EnumUnderlyingType().SpecialType;
-
-            // integral to double or float is never checked, but float/double to integral 
-            // may be checked.
-            bool sourceIsNumeric = SpecialType.System_Char <= sourceST && sourceST <= SpecialType.System_Double;
-            bool targetIsNumeric = SpecialType.System_Char <= targetST && targetST <= SpecialType.System_UInt64;
-
-            return
-                sourceIsNumeric && (targetIsNumeric || target.IsPointerType()) ||
-                targetIsNumeric && source.IsPointerType();
-        }
-
         protected BoundExpression CreateUserDefinedConversion(SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, TypeSymbol destination, DiagnosticBag diagnostics)
         {
             if (!conversion.IsValid)
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
index 94fa633b2e4a9..0b545e0c4daa7 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
@@ -108,9 +108,11 @@ private BoundExpression MakeConversionNode(
         {
             Debug.Assert(oldNode == null || oldNode.Syntax == syntax);
             Debug.Assert((object)rewrittenType != null);
-            @checked = @checked &&
-                (_inExpressionLambda && (explicitCastInCode || DistinctSpecialTypes(rewrittenOperand.Type, rewrittenType)) ||
-                NeedsChecked(rewrittenOperand.Type, rewrittenType));
+
+            if (_inExpressionLambda)
+            {
+                @checked = @checked && NeedsCheckedConversionInExpressionTree(rewrittenOperand.Type, rewrittenType, explicitCastInCode);
+            }
 
             switch (conversion.Kind)
             {
@@ -373,53 +375,8 @@ private BoundExpression MakeConversionNode(
                     type: rewrittenType);
         }
 
-        private static bool DistinctSpecialTypes(TypeSymbol source, TypeSymbol target)
-        {
-            Debug.Assert((object)target != null);
-
-            if ((object)source == null)
-            {
-                return false;
-            }
-
-            SpecialType sourceST = source.StrippedType().EnumUnderlyingType().SpecialType;
-            SpecialType targetST = target.StrippedType().EnumUnderlyingType().SpecialType;
-            return sourceST != targetST;
-        }
-
-        private const bool y = true;
-        private const bool n = false;
-
-        private static readonly bool[,] s_needsChecked =
-            {   //         chri08u08i16u16i32u32i64u64
-            /* chr */
-                          { n, y, y, y, n, n, n, n, n },
-            /* i08 */
-                          { y, n, y, n, y, n, y, n, y },
-            /* u08 */
-                          { n, y, n, n, n, n, n, n, n },
-            /* i16 */
-                          { y, y, y, n, y, n, y, n, y },
-            /* u16 */
-                          { n, y, y, y, n, n, n, n, n },
-            /* i32 */
-                          { y, y, y, y, y, n, y, n, y },
-            /* u32 */
-                          { y, y, y, y, y, y, n, n, n },
-            /* i64 */
-                          { y, y, y, y, y, y, y, n, y },
-            /* u64 */
-                          { y, y, y, y, y, y, y, y, n },
-            /* dec */
-                          { n, n, n, n, n, n, n, n, n },
-            /* r32 */
-                          { y, y, y, y, y, y, y, y, y },
-            /* r64 */
-                          { y, y, y, y, y, y, y, y, y },
-            };
-
         // Determine if the conversion can actually overflow at runtime.  If not, no need to generate a checked instruction.
-        private static bool NeedsChecked(TypeSymbol source, TypeSymbol target)
+        private static bool NeedsCheckedConversionInExpressionTree(TypeSymbol source, TypeSymbol target, bool explicitCastInCode)
         {
             Debug.Assert((object)target != null);
 
@@ -428,22 +385,20 @@ private static bool NeedsChecked(TypeSymbol source, TypeSymbol target)
                 return false;
             }
 
-            if (source.IsDynamic())
-            {
-                return true;
-            }
+            SpecialType GetUnderlyingSpecialType(TypeSymbol type) =>
+                type.StrippedType().EnumUnderlyingType().SpecialType;
+
+            bool IsInRange(SpecialType type, SpecialType low, SpecialType high) =>
+                low <= type && type <= high;
 
-            SpecialType sourceST = source.StrippedType().EnumUnderlyingType().SpecialType;
-            SpecialType targetST = target.StrippedType().EnumUnderlyingType().SpecialType;
+            SpecialType sourceST = GetUnderlyingSpecialType(source);
+            SpecialType targetST = GetUnderlyingSpecialType(target);
 
             // integral to double or float is never checked, but float/double to integral 
             // may be checked.
-            bool sourceIsNumeric = SpecialType.System_Char <= sourceST && sourceST <= SpecialType.System_Double;
-            bool targetIsNumeric = SpecialType.System_Char <= targetST && targetST <= SpecialType.System_UInt64;
-            return
-                sourceIsNumeric && target.IsPointerType() ||
-                targetIsNumeric && source.IsPointerType() ||
-                sourceIsNumeric && targetIsNumeric && s_needsChecked[sourceST - SpecialType.System_Char, targetST - SpecialType.System_Char];
+            return (explicitCastInCode || sourceST != targetST) &&
+                IsInRange(sourceST, SpecialType.System_Char, SpecialType.System_Double) &&
+                IsInRange(targetST, SpecialType.System_Char, SpecialType.System_UInt64);
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenCheckedTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenCheckedTests.cs
index b6ad41829bbd3..1886c8c03e445 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenCheckedTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenCheckedTests.cs
@@ -2367,5 +2367,416 @@ .locals init (int V_0)
 }
 ");
         }
+
+        [Fact]
+        public void CheckedConversionsInExpressionTrees_Implicit()
+        {
+            // char
+            CheckedConversionInExpressionTree_Implicit("char", "char", ConvertMethod.None);
+            CheckedConversionInExpressionTree_Implicit("char", "ushort", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("char", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("char", "uint", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("char", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("char", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("char", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("char", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("char", "double", ConvertMethod.Convert);
+
+            // sbyte
+            CheckedConversionInExpressionTree_Implicit("sbyte", "sbyte", ConvertMethod.None);
+            CheckedConversionInExpressionTree_Implicit("sbyte", "short", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("sbyte", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("sbyte", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("sbyte", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("sbyte", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("sbyte", "double", ConvertMethod.Convert);
+
+            // byte
+            CheckedConversionInExpressionTree_Implicit("byte", "byte", ConvertMethod.None);
+            CheckedConversionInExpressionTree_Implicit("byte", "short", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("byte", "ushort", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("byte", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("byte", "uint", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("byte", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("byte", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("byte", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("byte", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("byte", "double", ConvertMethod.Convert);
+
+            // short
+            CheckedConversionInExpressionTree_Implicit("short", "short", ConvertMethod.None);
+            CheckedConversionInExpressionTree_Implicit("short", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("short", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("short", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("short", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("short", "double", ConvertMethod.Convert);
+
+            // ushort
+            CheckedConversionInExpressionTree_Implicit("ushort", "ushort", ConvertMethod.None);
+            CheckedConversionInExpressionTree_Implicit("ushort", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("ushort", "uint", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("ushort", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("ushort", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("ushort", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("ushort", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("ushort", "double", ConvertMethod.Convert);
+
+            // int
+            CheckedConversionInExpressionTree_Implicit("int", "int", ConvertMethod.None);
+            CheckedConversionInExpressionTree_Implicit("int", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("int", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("int", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("int", "double", ConvertMethod.Convert);
+
+            // uint
+            CheckedConversionInExpressionTree_Implicit("uint", "uint", ConvertMethod.None);
+            CheckedConversionInExpressionTree_Implicit("uint", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("uint", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Implicit("uint", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("uint", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("uint", "double", ConvertMethod.Convert);
+
+            // long
+            CheckedConversionInExpressionTree_Implicit("long", "long", ConvertMethod.None);
+            CheckedConversionInExpressionTree_Implicit("long", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("long", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("long", "double", ConvertMethod.Convert);
+
+            // ulong
+            CheckedConversionInExpressionTree_Implicit("ulong", "ulong", ConvertMethod.None);
+            CheckedConversionInExpressionTree_Implicit("ulong", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("ulong", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("ulong", "double", ConvertMethod.Convert);
+
+            // decimal
+            CheckedConversionInExpressionTree_Implicit("decimal", "decimal", ConvertMethod.None);
+
+            // float
+            CheckedConversionInExpressionTree_Implicit("float", "float", ConvertMethod.None);
+            CheckedConversionInExpressionTree_Implicit("float", "double", ConvertMethod.Convert);
+
+            // double
+            CheckedConversionInExpressionTree_Implicit("double", "double", ConvertMethod.None);
+
+            // object
+            CheckedConversionInExpressionTree_Implicit("int", "object", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Implicit("string", "object", ConvertMethod.None);
+
+            // Nullable<>
+            CheckedConversionInExpressionTree_Implicit("int", "int?", "arg => F(Convert(arg))");
+            CheckedConversionInExpressionTree_Implicit("int", "long?", "arg => F(ConvertChecked(ConvertChecked(arg)))");
+        }
+
+        [Fact]
+        [WorkItem(18459, "https://github.com/dotnet/roslyn/issues/18459")]
+        public void CheckedConversionsInExpressionTrees_ImplicitTuple()
+        {
+            CheckedConversionInExpressionTree_Implicit("(int, int)", "(int, int)?", ConvertMethod.Convert);
+        }
+
+        [Fact]
+        public void CheckedConversionsInExpressionTrees_Explicit()
+        {
+            // char
+            CheckedConversionInExpressionTree_Explicit("char", "char", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("char", "sbyte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("char", "byte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("char", "short", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("char", "ushort", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("char", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("char", "uint", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("char", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("char", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("char", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("char", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("char", "double", ConvertMethod.Convert);
+
+            // sbyte
+            CheckedConversionInExpressionTree_Explicit("sbyte", "char", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("sbyte", "sbyte", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("sbyte", "byte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("sbyte", "short", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("sbyte", "ushort", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("sbyte", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("sbyte", "uint", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("sbyte", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("sbyte", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("sbyte", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("sbyte", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("sbyte", "double", ConvertMethod.Convert);
+
+            // byte
+            CheckedConversionInExpressionTree_Explicit("byte", "char", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("byte", "sbyte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("byte", "byte", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("byte", "short", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("byte", "ushort", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("byte", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("byte", "uint", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("byte", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("byte", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("byte", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("byte", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("byte", "double", ConvertMethod.Convert);
+
+            // short
+            CheckedConversionInExpressionTree_Explicit("short", "char", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("short", "sbyte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("short", "byte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("short", "short", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("short", "ushort", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("short", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("short", "uint", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("short", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("short", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("short", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("short", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("short", "double", ConvertMethod.Convert);
+
+            // ushort
+            CheckedConversionInExpressionTree_Explicit("ushort", "char", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ushort", "sbyte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ushort", "byte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ushort", "short", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ushort", "ushort", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("ushort", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ushort", "uint", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ushort", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ushort", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ushort", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("ushort", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("ushort", "double", ConvertMethod.Convert);
+
+            // int
+            CheckedConversionInExpressionTree_Explicit("int", "char", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("int", "sbyte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("int", "byte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("int", "short", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("int", "ushort", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("int", "int", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("int", "uint", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("int", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("int", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("int", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("int", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("int", "double", ConvertMethod.Convert);
+
+            // uint
+            CheckedConversionInExpressionTree_Explicit("uint", "char", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("uint", "sbyte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("uint", "byte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("uint", "short", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("uint", "ushort", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("uint", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("uint", "uint", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("uint", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("uint", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("uint", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("uint", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("uint", "double", ConvertMethod.Convert);
+
+            // long
+            CheckedConversionInExpressionTree_Explicit("long", "char", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("long", "sbyte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("long", "byte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("long", "short", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("long", "ushort", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("long", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("long", "uint", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("long", "long", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("long", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("long", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("long", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("long", "double", ConvertMethod.Convert);
+
+            // ulong
+            CheckedConversionInExpressionTree_Explicit("ulong", "char", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ulong", "sbyte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ulong", "byte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ulong", "short", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ulong", "ushort", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ulong", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ulong", "uint", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ulong", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("ulong", "ulong", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("ulong", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("ulong", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("ulong", "double", ConvertMethod.Convert);
+
+            // decimal
+            CheckedConversionInExpressionTree_Explicit("decimal", "char", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("decimal", "sbyte", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("decimal", "byte", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("decimal", "short", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("decimal", "ushort", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("decimal", "int", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("decimal", "uint", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("decimal", "long", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("decimal", "ulong", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("decimal", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("decimal", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("decimal", "double", ConvertMethod.Convert);
+
+            // float
+            CheckedConversionInExpressionTree_Explicit("float", "char", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("float", "sbyte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("float", "byte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("float", "short", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("float", "ushort", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("float", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("float", "uint", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("float", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("float", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("float", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("float", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("float", "double", ConvertMethod.Convert);
+
+            // double
+            CheckedConversionInExpressionTree_Explicit("double", "char", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("double", "sbyte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("double", "byte", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("double", "short", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("double", "ushort", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("double", "int", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("double", "uint", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("double", "long", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("double", "ulong", ConvertMethod.ConvertChecked);
+            CheckedConversionInExpressionTree_Explicit("double", "decimal", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("double", "float", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("double", "double", ConvertMethod.Convert);
+
+            // enum
+            CheckedConversionInExpressionTree_Explicit("E", "int", ConvertMethod.ConvertChecked, "enum E { }");
+            CheckedConversionInExpressionTree_Explicit("int", "E", ConvertMethod.ConvertChecked, "enum E { }");
+            CheckedConversionInExpressionTree_Explicit("E", "int", ConvertMethod.ConvertChecked, "enum E : short { }");
+            CheckedConversionInExpressionTree_Explicit("int", "E", ConvertMethod.ConvertChecked, "enum E : short { }");
+
+            // object
+            CheckedConversionInExpressionTree_Explicit("int", "object", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("object", "int", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("string", "object", ConvertMethod.Convert);
+            CheckedConversionInExpressionTree_Explicit("object", "string", ConvertMethod.Convert);
+
+            // Nullable<>
+            CheckedConversionInExpressionTree_Explicit("int", "byte?", "arg => ConvertChecked(arg)");
+            CheckedConversionInExpressionTree_Explicit("int", "int?", "arg => ConvertChecked(arg)");
+            CheckedConversionInExpressionTree_Explicit("int", "long?", "arg => ConvertChecked(ConvertChecked(arg))");
+        }
+
+        [Fact]
+        public void CheckedConversionsInExpressionTrees_ExplicitTuple()
+        {
+            CheckedConversionInExpressionTree_Explicit("(int, int)", "(int, int)?", ConvertMethod.Convert);
+        }
+
+        private enum ConvertMethod
+        {
+            None,
+            Convert,
+            ConvertChecked,
+        }
+
+        private void CheckedConversionInExpressionTree_Implicit(string fromType, string toType, ConvertMethod expectedMethod, string additionalTypes = "")
+        {
+            var source = CheckedConversionInExpressionTree_ImplicitSource(fromType, toType, additionalTypes);
+            var compilation = CreateCompilationWithMscorlibAndSystemCore(source, options: TestOptions.ReleaseExe, references: new[] { ValueTupleRef, SystemRuntimeFacadeRef });
+            string expectedOutput;
+            switch (expectedMethod)
+            {
+                default:
+                    expectedOutput = "arg => F(arg)";
+                    break;
+                case ConvertMethod.Convert:
+                    expectedOutput = "arg => F(Convert(arg))";
+                    break;
+                case ConvertMethod.ConvertChecked:
+                    expectedOutput = "arg => F(ConvertChecked(arg))";
+                    break;
+            }
+            var verifier = CompileAndVerify(compilation, expectedOutput: expectedOutput);
+            // Since Expression.ConvertChecked can generate a Checked result
+            // (rather than ConvertChecked), verify the correct method was called.
+            VerifyConversionInExpressionTreeIL(verifier.TestData.GetMethodData("C.Main").GetMethodIL(), expectedMethod);
+        }
+
+        private void CheckedConversionInExpressionTree_Implicit(string fromType, string toType, string expectedOutput)
+        {
+            var source = CheckedConversionInExpressionTree_ImplicitSource(fromType, toType, additionalTypes: "");
+            var compilation = CreateCompilationWithMscorlibAndSystemCore(source, options: TestOptions.ReleaseExe);
+            CompileAndVerify(compilation, expectedOutput: expectedOutput);
+        }
+
+        private static string CheckedConversionInExpressionTree_ImplicitSource(string fromType, string toType, string additionalTypes)
+        {
+            return
+$@"using System;
+using System.Linq.Expressions;
+{additionalTypes}
+class C
+{{
+    static {toType} F({toType} arg) => arg;
+    static void Main()
+    {{
+        Expression<Func<{fromType}, {toType}>> e = arg => checked(F(arg));
+        Console.WriteLine(e);
+    }}
+}}";
+        }
+
+        private void CheckedConversionInExpressionTree_Explicit(string fromType, string toType, ConvertMethod expectedMethod, string additionalTypes = "")
+        {
+            var source = CheckedConversionInExpressionTree_ExplicitSource(fromType, toType, additionalTypes);
+            var compilation = CreateCompilationWithMscorlibAndSystemCore(source, options: TestOptions.ReleaseExe, references: new[] { ValueTupleRef, SystemRuntimeFacadeRef });
+            string expectedOutput;
+            switch (expectedMethod)
+            {
+                default:
+                    expectedOutput = "arg => arg";
+                    break;
+                case ConvertMethod.Convert:
+                    expectedOutput = "arg => Convert(arg)";
+                    break;
+                case ConvertMethod.ConvertChecked:
+                    expectedOutput = "arg => ConvertChecked(arg)";
+                    break;
+            }
+            var verifier = CompileAndVerify(compilation, expectedOutput: expectedOutput);
+            // Since Expression.ConvertChecked can generate a Checked result
+            // (rather than ConvertChecked), verify the correct method was called.
+            VerifyConversionInExpressionTreeIL(verifier.TestData.GetMethodData("C.Main").GetMethodIL(), expectedMethod);
+        }
+
+        private void CheckedConversionInExpressionTree_Explicit(string fromType, string toType, string expectedOutput)
+        {
+            var source = CheckedConversionInExpressionTree_ExplicitSource(fromType, toType, additionalTypes: "");
+            var compilation = CreateCompilationWithMscorlibAndSystemCore(source, options: TestOptions.ReleaseExe);
+            CompileAndVerify(compilation, expectedOutput: expectedOutput);
+        }
+
+        private static string CheckedConversionInExpressionTree_ExplicitSource(string fromType, string toType, string additionalTypes)
+        {
+            return
+$@"using System;
+using System.Linq.Expressions;
+{additionalTypes}
+class C
+{{
+    static void Main()
+    {{
+        Expression<Func<{fromType}, {toType}>> e = arg => checked(({toType})arg);
+        Console.WriteLine(e);
+    }}
+}}";
+        }
+
+        private static void VerifyConversionInExpressionTreeIL(string actualIL, ConvertMethod expectedMethod)
+        {
+            Assert.Equal(
+                actualIL.Contains($"System.Linq.Expressions.Expression.Convert(System.Linq.Expressions.Expression, "),
+                expectedMethod == ConvertMethod.Convert);
+            Assert.Equal(
+                actualIL.Contains($"System.Linq.Expressions.Expression.ConvertChecked(System.Linq.Expressions.Expression, "),
+                expectedMethod == ConvertMethod.ConvertChecked);
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs
index 8230e560a567e..7675c2e870bfb 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs
@@ -22751,7 +22751,6 @@ static void Main()
                 //         System.Console.WriteLine(notAliteral.M());
                 Diagnostic(ErrorCode.ERR_BadExtensionArgTypes, "M").WithArguments("(int A, int B)", "M", "C.M((int x, long y))").WithLocation(23, 46)
                 );
-
         }
 
         [Fact]
@@ -22873,6 +22872,138 @@ void M<T>()
                 );
         }
 
+        [Fact]
+        public void CheckedConstantConversions()
+        {
+            var source =
+@"#pragma warning disable 219
+class C
+{
+    static void Main()
+    {
+        unchecked
+        {
+            var u = ((byte, byte))(0, -1);
+            var (a, b) = ((byte, byte))(0, -2);
+        }
+        checked
+        {
+            var c = ((byte, byte))(0, -1);
+            var (a, b) = ((byte, byte))(0, -2);
+        }
+    }
+}";
+            var comp = CreateStandardCompilation(
+                source,
+                references: new[] { ValueTupleRef, SystemRuntimeFacadeRef },
+                options: TestOptions.ReleaseExe);
+            comp.VerifyDiagnostics(
+                // (13,39): error CS0221: Constant value '-1' cannot be converted to a 'byte' (use 'unchecked' syntax to override)
+                //             var c = ((byte, byte))(0, -1);
+                Diagnostic(ErrorCode.ERR_ConstOutOfRangeChecked, "-1").WithArguments("-1", "byte").WithLocation(13, 39),
+                // (14,44): error CS0221: Constant value '-2' cannot be converted to a 'byte' (use 'unchecked' syntax to override)
+                //             var (a, b) = ((byte, byte))(0, -2);
+                Diagnostic(ErrorCode.ERR_ConstOutOfRangeChecked, "-2").WithArguments("-2", "byte").WithLocation(14, 44));
+        }
+
+        [Fact]
+        [WorkItem(18459, "https://github.com/dotnet/roslyn/issues/18459")]
+        public void CheckedConversions()
+        {
+            var source =
+@"using System;
+class C
+{
+    static (long, byte) Default((int, int) t)
+    {
+        return ((long, byte))t;
+    }
+    static (long, byte) Unchecked((int, int) t)
+    {
+        unchecked
+        {
+            return ((long, byte))t;
+        }
+    }
+    static (long, byte) Checked((int, int) t)
+    {
+        checked
+        {
+            return ((long, byte))t;
+        }
+    }
+    static void Main()
+    {
+        var d = Default((-1, -1));
+        Console.Write(d);
+        var u = Unchecked((-1, -1));
+        Console.Write(u);
+        try
+        {
+            var c = Checked((-1, -1));
+            Console.Write(c);
+        }
+        catch (OverflowException)
+        {
+            Console.Write(""overflow"");
+        }
+    }
+}";
+            var comp = CreateStandardCompilation(
+                source,
+                references: new[] { ValueTupleRef, SystemRuntimeFacadeRef },
+                options: TestOptions.ReleaseExe);
+            var verifier = CompileAndVerify(comp, expectedOutput: @"(-1, 255)(-1, 255)overflow");
+            verifier.VerifyIL("C.Default",
+@"{
+  // Code size       22 (0x16)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, int> V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloc.0
+  IL_0003:  ldfld      ""int System.ValueTuple<int, int>.Item1""
+  IL_0008:  conv.i8
+  IL_0009:  ldloc.0
+  IL_000a:  ldfld      ""int System.ValueTuple<int, int>.Item2""
+  IL_000f:  conv.u1
+  IL_0010:  newobj     ""System.ValueTuple<long, byte>..ctor(long, byte)""
+  IL_0015:  ret
+}");
+            verifier.VerifyIL("C.Unchecked",
+@"{
+  // Code size       22 (0x16)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, int> V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloc.0
+  IL_0003:  ldfld      ""int System.ValueTuple<int, int>.Item1""
+  IL_0008:  conv.i8
+  IL_0009:  ldloc.0
+  IL_000a:  ldfld      ""int System.ValueTuple<int, int>.Item2""
+  IL_000f:  conv.u1
+  IL_0010:  newobj     ""System.ValueTuple<long, byte>..ctor(long, byte)""
+  IL_0015:  ret
+}");
+            verifier.VerifyIL("C.Checked",
+@"{
+  // Code size       22 (0x16)
+  .maxstack  2
+  .locals init (System.ValueTuple<int, int> V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloc.0
+  IL_0003:  ldfld      ""int System.ValueTuple<int, int>.Item1""
+  IL_0008:  conv.i8
+  IL_0009:  ldloc.0
+  IL_000a:  ldfld      ""int System.ValueTuple<int, int>.Item2""
+  IL_000f:  conv.ovf.u1
+  IL_0010:  newobj     ""System.ValueTuple<long, byte>..ctor(long, byte)""
+  IL_0015:  ret
+}");
+        }
+
         [Fact]
         [WorkItem(19434, "https://github.com/dotnet/roslyn/issues/19434")]
         public void ExplicitTupleLiteralConversionWithNullable01()
@@ -22946,4 +23077,4 @@ .locals init (int V_0, //x
 ");
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTuples.vb b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTuples.vb
index 63170568905e5..27e9f590bd731 100644
--- a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTuples.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTuples.vb
@@ -20200,6 +20200,71 @@ End Namespace
 
         End Sub
 
+        <Fact>
+        Public Sub CheckedConversions()
+            Dim source =
+<compilation>
+    <file>
+Imports System
+Class C
+    Shared Function F(t As (Integer, Integer)) As (Long, Byte)
+        Return CType(t, (Long, Byte))
+    End Function
+    Shared Sub Main()
+        Try
+            Dim t = F((-1, -1))
+            Console.WriteLine(t)
+        Catch e As OverflowException
+            Console.WriteLine("overflow")
+        End Try
+    End Sub
+End Class
+    </file>
+</compilation>
+            Dim verifier = CompileAndVerify(
+                source,
+                options:=TestOptions.ReleaseExe.WithOverflowChecks(False),
+                additionalRefs:=s_valueTupleRefs, expectedOutput:=<![CDATA[(-1, 255)]]>)
+            verifier.VerifyIL("C.F", <![CDATA[
+{
+  // Code size       22 (0x16)
+  .maxstack  2
+  .locals init (System.ValueTuple(Of Integer, Integer) V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloc.0
+  IL_0003:  ldfld      "System.ValueTuple(Of Integer, Integer).Item1 As Integer"
+  IL_0008:  conv.i8
+  IL_0009:  ldloc.0
+  IL_000a:  ldfld      "System.ValueTuple(Of Integer, Integer).Item2 As Integer"
+  IL_000f:  conv.u1
+  IL_0010:  newobj     "Sub System.ValueTuple(Of Long, Byte)..ctor(Long, Byte)"
+  IL_0015:  ret
+}
+]]>)
+            verifier = CompileAndVerify(
+                source,
+                options:=TestOptions.ReleaseExe.WithOverflowChecks(True),
+                additionalRefs:=s_valueTupleRefs, expectedOutput:=<![CDATA[overflow]]>)
+            verifier.VerifyIL("C.F", <![CDATA[
+{
+  // Code size       22 (0x16)
+  .maxstack  2
+  .locals init (System.ValueTuple(Of Integer, Integer) V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.0
+  IL_0002:  ldloc.0
+  IL_0003:  ldfld      "System.ValueTuple(Of Integer, Integer).Item1 As Integer"
+  IL_0008:  conv.i8
+  IL_0009:  ldloc.0
+  IL_000a:  ldfld      "System.ValueTuple(Of Integer, Integer).Item2 As Integer"
+  IL_000f:  conv.ovf.u1
+  IL_0010:  newobj     "Sub System.ValueTuple(Of Long, Byte)..ctor(Long, Byte)"
+  IL_0015:  ret
+}
+]]>)
+        End Sub
+
     End Class
 
 End Namespace