Merge remote-tracking branch 'dotnet/master' into AddMockClipboard

src/Compilers/CSharp/Portable/CSharpCompilationOptions.cs

@@ -443,7 +443,7 @@ public CSharpCompilationOptions WithConcurrentBuild(bool concurrentBuild)
             return new CSharpCompilationOptions(this) { ConcurrentBuild = concurrentBuild };
         }
 
-        public CSharpCompilationOptions WithDeterminism(bool deterministic)
+        public CSharpCompilationOptions WithDeterministic(bool deterministic)
         {
             if (deterministic == this.Deterministic)
             {

src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt

@@ -4,7 +4,7 @@
 Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, bool reportSuppressedDiagnostics, string moduleName = null, string mainTypeName = null, string scriptClassName = null, System.Collections.Generic.IEnumerable<string> usings = null, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel = Microsoft.CodeAnalysis.OptimizationLevel.Debug, bool checkOverflow = false, bool allowUnsafe = false, string cryptoKeyContainer = null, string cryptoKeyFile = null, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey = default(System.Collections.Immutable.ImmutableArray<byte>), bool? delaySign = null, Microsoft.CodeAnalysis.Platform platform = Microsoft.CodeAnalysis.Platform.AnyCpu, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption = Microsoft.CodeAnalysis.ReportDiagnostic.Default, int warningLevel = 4, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, Microsoft.CodeAnalysis.ReportDiagnostic>> specificDiagnosticOptions = null, bool concurrentBuild = true, bool deterministic = true, Microsoft.CodeAnalysis.XmlReferenceResolver xmlReferenceResolver = null, Microsoft.CodeAnalysis.SourceReferenceResolver sourceReferenceResolver = null, Microsoft.CodeAnalysis.MetadataReferenceResolver metadataReferenceResolver = null, Microsoft.CodeAnalysis.AssemblyIdentityComparer assemblyIdentityComparer = null, Microsoft.CodeAnalysis.StrongNameProvider strongNameProvider = null) -> void
 Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, string moduleName = null, string mainTypeName = null, string scriptClassName = null, System.Collections.Generic.IEnumerable<string> usings = null, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel = Microsoft.CodeAnalysis.OptimizationLevel.Debug, bool checkOverflow = false, bool allowUnsafe = false, string cryptoKeyContainer = null, string cryptoKeyFile = null, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey = default(System.Collections.Immutable.ImmutableArray<byte>), bool? delaySign = null, Microsoft.CodeAnalysis.Platform platform = Microsoft.CodeAnalysis.Platform.AnyCpu, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption = Microsoft.CodeAnalysis.ReportDiagnostic.Default, int warningLevel = 4, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, Microsoft.CodeAnalysis.ReportDiagnostic>> specificDiagnosticOptions = null, bool concurrentBuild = true, bool deterministic = false, Microsoft.CodeAnalysis.XmlReferenceResolver xmlReferenceResolver = null, Microsoft.CodeAnalysis.SourceReferenceResolver sourceReferenceResolver = null, Microsoft.CodeAnalysis.MetadataReferenceResolver metadataReferenceResolver = null, Microsoft.CodeAnalysis.AssemblyIdentityComparer assemblyIdentityComparer = null, Microsoft.CodeAnalysis.StrongNameProvider strongNameProvider = null) -> void
 Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, string moduleName, string mainTypeName, string scriptClassName, System.Collections.Generic.IEnumerable<string> usings, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel, bool checkOverflow, bool allowUnsafe, string cryptoKeyContainer, string cryptoKeyFile, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey, bool? delaySign, Microsoft.CodeAnalysis.Platform platform, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption, int warningLevel, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, Microsoft.CodeAnalysis.ReportDiagnostic>> specificDiagnosticOptions, bool concurrentBuild, Microsoft.CodeAnalysis.XmlReferenceResolver xmlReferenceResolver, Microsoft.CodeAnalysis.SourceReferenceResolver sourceReferenceResolver, Microsoft.CodeAnalysis.MetadataReferenceResolver metadataReferenceResolver, Microsoft.CodeAnalysis.AssemblyIdentityComparer assemblyIdentityComparer, Microsoft.CodeAnalysis.StrongNameProvider strongNameProvider) -> void
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithDeterminism(bool deterministic) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithDeterministic(bool deterministic) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
 Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithReportSuppressedDiagnostics(bool reportSuppressedDiagnostics) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
 Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithKind(Microsoft.CodeAnalysis.SourceCodeKind kind) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions
 Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.GetLoadDirectives() -> System.Collections.Generic.IList<Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax>

src/Compilers/CSharp/Test/Emit/Emit/DeterministicTests.cs

@@ -21,7 +21,7 @@ private Guid CompiledGuid(string source, string assemblyName, bool debug)
             var compilation = CreateCompilation(source,
                 assemblyName: assemblyName,
                 references: new[] { MscorlibRef },
-                options: (debug ? TestOptions.DebugExe : TestOptions.ReleaseExe).WithDeterminism(true));
+                options: (debug ? TestOptions.DebugExe : TestOptions.ReleaseExe).WithDeterministic(true));
 
             Guid result = default(Guid);
             base.CompileAndVerify(compilation, validator: a =>
@@ -35,7 +35,7 @@ private Guid CompiledGuid(string source, string assemblyName, bool debug)
 
         private ImmutableArray<byte> EmitDeterministic(string source, Platform platform, DebugInformationFormat pdbFormat, bool optimize)
         {
-            var options = (optimize ? TestOptions.ReleaseExe : TestOptions.DebugExe).WithPlatform(platform).WithDeterminism(true);
+            var options = (optimize ? TestOptions.ReleaseExe : TestOptions.DebugExe).WithPlatform(platform).WithDeterministic(true);
 
             var compilation = CreateCompilation(source, assemblyName: "DeterminismTest", references: new[] { MscorlibRef }, options: options);
 
@@ -56,12 +56,12 @@ public void BanVersionWildcards()
             var compilationDeterministic = CreateCompilation(
                 source,
                 assemblyName: "DeterminismTest", references: new[] { MscorlibRef },
-                options: TestOptions.DebugDll.WithDeterminism(true));
+                options: TestOptions.DebugDll.WithDeterministic(true));
             var compilationNonDeterministic = CreateCompilation(
                 source, 
                 assemblyName: "DeterminismTest", 
                 references: new[] { MscorlibRef },
-                options: TestOptions.DebugDll.WithDeterminism(false));
+                options: TestOptions.DebugDll.WithDeterministic(false));
 
             var resultDeterministic = compilationDeterministic.Emit(Stream.Null, Stream.Null);
             var resultNonDeterministic = compilationNonDeterministic.Emit(Stream.Null, Stream.Null);
@@ -158,7 +158,7 @@ public void TestWriteOnlyStream()
             var compilation = CSharpCompilation.Create("Program",
                                                        new[] { tree },
                                                        new[] { MetadataReference.CreateFromAssemblyInternal(typeof(object).Assembly) },
-                                                       new CSharpCompilationOptions(OutputKind.ConsoleApplication).WithDeterminism(true));
+                                                       new CSharpCompilationOptions(OutputKind.ConsoleApplication).WithDeterministic(true));
             var output = new WriteOnlyStream();
             compilation.Emit(output);
         }

src/Compilers/CSharp/Test/Emit/Emit/EmitMetadata.cs

@@ -2148,7 +2148,7 @@ public unsafe void PEHeaders1()
 
             var peStream = CreateCompilationWithMscorlib(
                 syntax,
-                options: TestOptions.ReleaseDll.WithDeterminism(true),
+                options: TestOptions.ReleaseDll.WithDeterministic(true),
                 assemblyName: "46B9C2B2-B7A0-45C5-9EF9-28DDF739FD9E").EmitToStream(options);
 
             peStream.Position = 0;
@@ -2337,7 +2337,7 @@ public void PEHeaders2()
 
             var peStream = CreateCompilationWithMscorlib(
                 syntax,
-                options: TestOptions.DebugExe.WithPlatform(Platform.X64).WithDeterminism(true),
+                options: TestOptions.DebugExe.WithPlatform(Platform.X64).WithDeterministic(true),
                 assemblyName: "B37A4FCD-ED76-4924-A2AD-298836056E00").EmitToStream(options);
 
             peStream.Position = 0;

src/Compilers/Core/MSBuildTask/Microsoft.VisualBasic.Core.targets

@@ -87,7 +87,7 @@
           NoWarnings="$(_NoWarnings)"
           NoWin32Manifest="$(NoWin32Manifest)"
           Optimize="$(Optimize)"
-          Deterministic="$Deterministic"
+          Deterministic="$(Deterministic)"
           OptionCompare="$(OptionCompare)"
           OptionExplicit="$(OptionExplicit)"
           OptionInfer="$(OptionInfer)"

src/Compilers/VisualBasic/Portable/PublicAPI.Unshipped.txt

@@ -10,7 +10,7 @@ Microsoft.CodeAnalysis.VisualBasic.SyntaxExtensions.NormalizeWhitespace(trivia A
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions.New(outputKind As Microsoft.CodeAnalysis.OutputKind, moduleName As String = Nothing, mainTypeName As String = Nothing, scriptClassName As String = "Script", globalImports As System.Collections.Generic.IEnumerable(Of Microsoft.CodeAnalysis.VisualBasic.GlobalImport) = Nothing, rootNamespace As String = Nothing, optionStrict As Microsoft.CodeAnalysis.VisualBasic.OptionStrict = Microsoft.CodeAnalysis.VisualBasic.OptionStrict.Off, optionInfer As Boolean = True, optionExplicit As Boolean = True, optionCompareText As Boolean = False, parseOptions As Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions = Nothing, embedVbCoreRuntime As Boolean = False, optimizationLevel As Microsoft.CodeAnalysis.OptimizationLevel = Microsoft.CodeAnalysis.OptimizationLevel.Debug, checkOverflow As Boolean = True, cryptoKeyContainer As String = Nothing, cryptoKeyFile As String = Nothing, cryptoPublicKey As System.Collections.Immutable.ImmutableArray(Of Byte) = Nothing, delaySign As Boolean? = Nothing, platform As Microsoft.CodeAnalysis.Platform = Microsoft.CodeAnalysis.Platform.AnyCpu, generalDiagnosticOption As Microsoft.CodeAnalysis.ReportDiagnostic = Microsoft.CodeAnalysis.ReportDiagnostic.Default, specificDiagnosticOptions As System.Collections.Generic.IEnumerable(Of System.Collections.Generic.KeyValuePair(Of String, Microsoft.CodeAnalysis.ReportDiagnostic)) = Nothing, concurrentBuild As Boolean = True, deterministic As Boolean = False, xmlReferenceResolver As Microsoft.CodeAnalysis.XmlReferenceResolver = Nothing, sourceReferenceResolver As Microsoft.CodeAnalysis.SourceReferenceResolver = Nothing, metadataReferenceResolver As Microsoft.CodeAnalysis.MetadataReferenceResolver = Nothing, assemblyIdentityComparer As Microsoft.CodeAnalysis.AssemblyIdentityComparer = Nothing, strongNameProvider As Microsoft.CodeAnalysis.StrongNameProvider = Nothing) -> Void
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions.New(outputKind As Microsoft.CodeAnalysis.OutputKind, moduleName As String, mainTypeName As String, scriptClassName As String, globalImports As System.Collections.Generic.IEnumerable(Of Microsoft.CodeAnalysis.VisualBasic.GlobalImport), rootNamespace As String, optionStrict As Microsoft.CodeAnalysis.VisualBasic.OptionStrict, optionInfer As Boolean, optionExplicit As Boolean, optionCompareText As Boolean, parseOptions As Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions, embedVbCoreRuntime As Boolean, optimizationLevel As Microsoft.CodeAnalysis.OptimizationLevel, checkOverflow As Boolean, cryptoKeyContainer As String, cryptoKeyFile As String, cryptoPublicKey As System.Collections.Immutable.ImmutableArray(Of Byte), delaySign As Boolean?, platform As Microsoft.CodeAnalysis.Platform, generalDiagnosticOption As Microsoft.CodeAnalysis.ReportDiagnostic, specificDiagnosticOptions As System.Collections.Generic.IEnumerable(Of System.Collections.Generic.KeyValuePair(Of String, Microsoft.CodeAnalysis.ReportDiagnostic)), concurrentBuild As Boolean, xmlReferenceResolver As Microsoft.CodeAnalysis.XmlReferenceResolver, sourceReferenceResolver As Microsoft.CodeAnalysis.SourceReferenceResolver, metadataReferenceResolver As Microsoft.CodeAnalysis.MetadataReferenceResolver, assemblyIdentityComparer As Microsoft.CodeAnalysis.AssemblyIdentityComparer, strongNameProvider As Microsoft.CodeAnalysis.StrongNameProvider) -> Void
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions.New(outputKind As Microsoft.CodeAnalysis.OutputKind, reportSuppressedDiagnostics As Boolean, moduleName As String = Nothing, mainTypeName As String = Nothing, scriptClassName As String = "Script", globalImports As System.Collections.Generic.IEnumerable(Of Microsoft.CodeAnalysis.VisualBasic.GlobalImport) = Nothing, rootNamespace As String = Nothing, optionStrict As Microsoft.CodeAnalysis.VisualBasic.OptionStrict = Microsoft.CodeAnalysis.VisualBasic.OptionStrict.Off, optionInfer As Boolean = True, optionExplicit As Boolean = True, optionCompareText As Boolean = False, parseOptions As Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions = Nothing, embedVbCoreRuntime As Boolean = False, optimizationLevel As Microsoft.CodeAnalysis.OptimizationLevel = Microsoft.CodeAnalysis.OptimizationLevel.Debug, checkOverflow As Boolean = True, cryptoKeyContainer As String = Nothing, cryptoKeyFile As String = Nothing, cryptoPublicKey As System.Collections.Immutable.ImmutableArray(Of Byte) = Nothing, delaySign As Boolean? = Nothing, platform As Microsoft.CodeAnalysis.Platform = Microsoft.CodeAnalysis.Platform.AnyCpu, generalDiagnosticOption As Microsoft.CodeAnalysis.ReportDiagnostic = Microsoft.CodeAnalysis.ReportDiagnostic.Default, specificDiagnosticOptions As System.Collections.Generic.IEnumerable(Of System.Collections.Generic.KeyValuePair(Of String, Microsoft.CodeAnalysis.ReportDiagnostic)) = Nothing, concurrentBuild As Boolean = True, deterministic As Boolean = False, xmlReferenceResolver As Microsoft.CodeAnalysis.XmlReferenceResolver = Nothing, sourceReferenceResolver As Microsoft.CodeAnalysis.SourceReferenceResolver = Nothing, metadataReferenceResolver As Microsoft.CodeAnalysis.MetadataReferenceResolver = Nothing, assemblyIdentityComparer As Microsoft.CodeAnalysis.AssemblyIdentityComparer = Nothing, strongNameProvider As Microsoft.CodeAnalysis.StrongNameProvider = Nothing) -> Void
-Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions.WithDeterminism(deterministic As Boolean) -> Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions
+Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions.WithDeterministic(deterministic As Boolean) -> Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions.WithReportSuppressedDiagnostics(value As Boolean) -> Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions.WithKind(kind As Microsoft.CodeAnalysis.SourceCodeKind) -> Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions.CommonWithKind(kind As Microsoft.CodeAnalysis.SourceCodeKind) -> Microsoft.CodeAnalysis.ParseOptions

src/Compilers/VisualBasic/Portable/VisualBasicCompilationOptions.vb

@@ -707,7 +707,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ''' <param name="deterministic"> The deterministic mode. </param>
         ''' <returns> A new instance of VisualBasicCompilationOptions, if the concurrent build is different; otherwise the current instance.</returns>
         ''' </summary>
-        Public Shadows Function WithDeterminism(deterministic As Boolean) As VisualBasicCompilationOptions
+        Public Shadows Function WithDeterministic(deterministic As Boolean) As VisualBasicCompilationOptions
             If deterministic = Me.Deterministic Then
                 Return Me
             End If

src/Compilers/VisualBasic/Test/Emit/Emit/DeterministicTests.vb

@@ -14,7 +14,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.Emit
         Inherits BasicTestBase
 
         Private Function GetBytesEmitted(source As String, platform As Platform, debug As Boolean) As ImmutableArray(Of Byte)
-            Dim options = If(debug, TestOptions.DebugExe, TestOptions.ReleaseExe).WithPlatform(platform).WithDeterminism(True)
+            Dim options = If(debug, TestOptions.DebugExe, TestOptions.ReleaseExe).WithPlatform(platform).WithDeterministic(True)
 
             Dim compilation = CreateCompilationWithMscorlib({source}, assemblyName:="DeterminismTest", options:=options)
 
@@ -35,10 +35,10 @@ Class C
 End Class"
             Dim compilationDeterministic = CreateCompilationWithMscorlib({source},
                                                                          assemblyName:="DeterminismTest",
-                                                                         options:=TestOptions.DebugExe.WithDeterminism(True))
+                                                                         options:=TestOptions.DebugExe.WithDeterministic(True))
             Dim compilationNonDeterministic = CreateCompilationWithMscorlib({source},
                                                                          assemblyName:="DeterminismTest",
-                                                                         options:=TestOptions.DebugExe.WithDeterminism(False))
+                                                                         options:=TestOptions.DebugExe.WithDeterministic(False))
 
             Dim resultDeterministic = compilationDeterministic.Emit(Stream.Null, Stream.Null)
             Dim resultNonDeterministic = compilationNonDeterministic.Emit(Stream.Null, Stream.Null)

src/EditorFeatures/CSharpTest/Classification/SyntacticClassifierTests.cs

@@ -3605,5 +3605,48 @@ public void LoadDirective()
                 PPKeyword("load"),
                 String("\"file.csx\""));
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public void IncompleteAwaitInNonAsyncContext()
+        {
+            var code = @"
+void M()
+{
+    var x = await
+}";
+            TestInClass(code,
+                Keyword("void"),
+                Identifier("M"),
+                Punctuation.OpenParen,
+                Punctuation.CloseParen,
+                Punctuation.OpenCurly,
+                Keyword("var"),
+                Identifier("x"),
+                Operators.Equals,
+                Keyword("await"),
+                Punctuation.CloseCurly);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public void CompleteAwaitInNonAsyncContext()
+        {
+            var code = @"
+void M()
+{
+    var x = await;
+}";
+            TestInClass(code,
+                Keyword("void"),
+                Identifier("M"),
+                Punctuation.OpenParen,
+                Punctuation.CloseParen,
+                Punctuation.OpenCurly,
+                Keyword("var"),
+                Identifier("x"),
+                Operators.Equals,
+                Identifier("await"),
+                Punctuation.Semicolon,
+                Punctuation.CloseCurly);
+        }
     }
 }

src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs

 // 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 Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.Editor.UnitTests;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Formatting.Rules;
-using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Text;
 using Roslyn.Test.Utilities;
 using Xunit;
@@ -2531,6 +2528,29 @@ class UserViewModel
                 expectedIndentation: 25);
         }
 
+        [WorkItem(5495, "https://github.com/dotnet/roslyn/issues/5495")]
+        [Fact, Trait(Traits.Feature, Traits.Features.SmartIndent)]
+        public void AfterPartialFromClause()
+        {
+            var code = @"
+using System.Linq;
+
+class C
+{
+    void M()
+    {
+        var q = from x
+
+    }
+}
+";
+
+            AssertSmartIndent(
+                code,
+                indentationLine: 8,
+                expectedIndentation: 16);
+        }
+
         private static void AssertSmartIndentInProjection(string markup, int expectedIndentation, CSharpParseOptions options = null)
         {
             var optionsSet = options != null

src/EditorFeatures/VisualBasicTest/Classification/SemanticClassifierTests.vb

@@ -518,5 +518,31 @@ End Class
                  Keyword("My"))
         End Sub
 
+        <Fact, Trait(Traits.Feature, Traits.Features.Classification)>
+        Public Sub TestAwaitInNonAsyncFunction1()
+            Dim text =
+<code>
+dim m = Await
+</code>.NormalizedValue()
+
+            TestInMethod(text,
+                 Keyword("Await"))
+        End Sub
+
+        <Fact, Trait(Traits.Feature, Traits.Features.Classification)>
+        Public Sub TestAwaitInNonAsyncFunction2()
+            Dim text =
+<code>
+sub await()
+end sub
+
+sub test()
+    dim m = Await
+end sub
+</code>.NormalizedValue()
+
+            TestInClass(text)
+        End Sub
+
     End Class
 End Namespace

src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/SymbolCompletionProviderTests.vb

@@ -6688,6 +6688,24 @@ Imports System
 Imports System.Collections.Generic
 Imports System.Linq
 
+Module Program
+    Sub Main(args As String())
+        Dim x = $$
+    End Sub
+End Module
+]]></code>.Value
+            VerifyItemIsAbsent(text, "Func(Of " & s_unicodeEllipsis & ")")
+        End Sub
+
+        <WorkItem(4428, "https://github.com/dotnet/roslyn/issues/4428")>
+        <Fact, Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Sub SystemFuncExcludedInStatementContext()
+            Dim text =
+<code><![CDATA[
+Imports System
+Imports System.Collections.Generic
+Imports System.Linq
+
 Module Program
     Sub Main(args As String())
         $$
@@ -6784,6 +6802,129 @@ End Module
             VerifyItemExists(text, "Delegate")
         End Sub
 
+        <WorkItem(4428, "https://github.com/dotnet/roslyn/issues/4428")>
+        <Fact, Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Sub SystemActionExcludedInExpressionContext1()
+            Dim text =
+<code><![CDATA[
+Imports System
+Imports System.Collections.Generic
+Imports System.Linq
+
+Module Program
+    Sub Main(args As String())
+        args.Select($$)
+    End Sub
+End Module
+]]></code>.Value
+            VerifyItemIsAbsent(text, "Action(Of " & s_unicodeEllipsis & ")")
+        End Sub
+
+        <WorkItem(4428, "https://github.com/dotnet/roslyn/issues/4428")>
+        <Fact, Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Sub SystemActionExcludedInExpressionContext2()
+            Dim text =
+<code><![CDATA[
+Imports System
+Imports System.Collections.Generic
+Imports System.Linq
+
+Module Program
+    Sub Main(args As String())
+        Dim x = $$
+    End Sub
+End Module
+]]></code>.Value
+            VerifyItemIsAbsent(text, "Action(Of " & s_unicodeEllipsis & ")")
+        End Sub
+
+        <WorkItem(4428, "https://github.com/dotnet/roslyn/issues/4428")>
+        <Fact, Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Sub SystemActionExcludedInStatementContext()
+            Dim text =
+<code><![CDATA[
+Imports System
+Imports System.Collections.Generic
+Imports System.Linq
+
+Module Program
+    Sub Main(args As String())
+        $$
+    End Sub
+End Module
+]]></code>.Value
+            VerifyItemIsAbsent(text, "Action(Of " & s_unicodeEllipsis & ")")
+        End Sub
+
+        <WorkItem(4428, "https://github.com/dotnet/roslyn/issues/4428")>
+        <Fact, Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Sub SystemActionIncludedInGetType()
+            Dim text =
+<code><![CDATA[
+Imports System
+Imports System.Collections.Generic
+Imports System.Linq
+
+Module Program
+    Sub Main(args As String())
+        GetType($$)
+    End Sub
+End Module
+]]></code>.Value
+            VerifyItemExists(text, "Action(Of " & s_unicodeEllipsis & ")")
+        End Sub
+
+        <WorkItem(4428, "https://github.com/dotnet/roslyn/issues/4428")>
+        <Fact, Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Sub SystemActionIncludedInTypeOf()
+            Dim text =
+<code><![CDATA[
+Imports System
+Imports System.Collections.Generic
+Imports System.Linq
+
+Module Program
+    Sub Main(args As String())
+        Dim s = TypeOf args Is $$
+    End Sub
+End Module
+]]></code>.Value
+            VerifyItemExists(text, "Action(Of " & s_unicodeEllipsis & ")")
+        End Sub
+
+        <WorkItem(4428, "https://github.com/dotnet/roslyn/issues/4428")>
+        <Fact, Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Sub SystemActionIncludedInReturnTypeContext()
+            Dim text =
+<code><![CDATA[
+Imports System
+Imports System.Collections.Generic
+Imports System.Linq
+
+Module Program
+    Function x() as $$
+    End Function
+End Module
+]]></code>.Value
+            VerifyItemExists(text, "Action(Of " & s_unicodeEllipsis & ")")
+        End Sub
+
+        <WorkItem(4428, "https://github.com/dotnet/roslyn/issues/4428")>
+        <Fact, Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Sub SystemActionIncludedInFieldTypeContext()
+            Dim text =
+<code><![CDATA[
+Imports System
+Imports System.Collections.Generic
+Imports System.Linq
+
+Module Program
+    Dim x as $$
+End Module
+]]></code>.Value
+            VerifyItemExists(text, "Action(Of " & s_unicodeEllipsis & ")")
+        End Sub
+
         <WorkItem(4428, "https://github.com/dotnet/roslyn/issues/4428")>
         <Fact, Trait(Traits.Feature, Traits.Features.Completion)>
         Public Sub SystemDelegateInExpressionContext()

src/InteractiveWindow/Editor/InteractiveWindow.csproj

@@ -90,7 +90,9 @@
     <Compile Include="Commands\InteractiveCommandsFactory.cs" />
     <Compile Include="IInteractiveWindowOperations.cs" />
     <Compile Include="IInteractiveWindowOperations2.cs" />
+    <Compile Include="InteractiveWindowClipboard.cs" />
     <Compile Include="InteractiveWindow.SpanRangeEdit.cs" />
+    <Compile Include="InteractiveWindow.SystemClipboard.cs" />
     <Compile Include="ProjectionBufferExtensions.cs" />
     <Compile Include="InteractiveWindow.PendingSubmission.cs" />
     <Compile Include="InteractiveWindow.ReplSpanKind.cs" />

src/InteractiveWindow/EditorTest/InteractiveWindowTest.csproj

@@ -80,6 +80,7 @@
     <Compile Include="HistoryTests.cs" />
     <Compile Include="InteractiveWindowHistoryTests.cs" />
     <Compile Include="InteractiveWindowTests.cs" />
+    <Compile Include="TestClipboard.cs" />
     <Compile Include="TestContentTypeDefinition.cs" />
     <Compile Include="TestInteractiveEngine.cs" />
     <Compile Include="TestSmartIndent.cs" />
@@ -95,4 +96,4 @@
     <Import Project="..\..\..\build\Targets\VSL.Imports.targets" />
     <Import Project="..\..\..\build\Targets\Roslyn.Toolsets.Xunit.targets" />
   </ImportGroup>
-</Project>
+</Project>
\ No newline at end of file

src/Workspaces/CSharp/Portable/Classification/ClassificationHelpers.cs

@@ -14,6 +14,7 @@ internal static class ClassificationHelpers
         private const string FromKeyword = "from";
         private const string ValueKeyword = "value";
         private const string VarKeyword = "var";
+        private const string AwaitKeyword = "await";
 
         /// <summary>
         /// Determine the classification type for a given token.
@@ -114,7 +115,7 @@ private static string GetClassificationForIdentifier(SyntaxToken token)
             {
                 return ClassificationTypeNames.TypeParameterName;
             }
-            else if (IsActualContextualKeyword(token) || CouldBeVarKeywordInDeclaration(token))
+            else if (IsActualContextualKeyword(token))
             {
                 return ClassificationTypeNames.Keyword;
             }
@@ -259,11 +260,20 @@ private static bool IsActualContextualKeyword(SyntaxToken token)
             {
                 switch (token.ValueText)
                 {
+                    case AwaitKeyword:
+                        return token.GetNextToken(includeZeroWidth: true).IsMissing;
+
                     case FromKeyword:
                         var fromClause = token.Parent.FirstAncestorOrSelf<FromClauseSyntax>();
                         return fromClause != null && fromClause.FromKeyword == token;
 
                     case VarKeyword:
+                        // var
+                        if (token.Parent is IdentifierNameSyntax && token.Parent?.Parent is ExpressionStatementSyntax)
+                        {
+                            return true;
+                        }
+
                         // we allow var any time it looks like a variable declaration, and is not in a
                         // field or event field.
                         return
@@ -277,18 +287,6 @@ private static bool IsActualContextualKeyword(SyntaxToken token)
             return false;
         }
 
-        private static bool CouldBeVarKeywordInDeclaration(SyntaxToken token)
-        {
-            if (token.ValueText == VarKeyword && token.Parent != null && token.Parent.Parent != null)
-            {
-                // cases:
-                //   var
-                return token.Parent is IdentifierNameSyntax && token.Parent.Parent is ExpressionStatementSyntax;
-            }
-
-            return false;
-        }
-
         internal static void AddLexicalClassifications(SourceText text, TextSpan textSpan, List<ClassifiedSpan> result, CancellationToken cancellationToken)
         {
             var text2 = text.ToString(textSpan);

src/Workspaces/CSharp/Portable/Formatting/Rules/QueryExpressionFormattingRule.cs

@@ -26,6 +26,36 @@ public override void AddSuppressOperations(List<SuppressOperation> list, SyntaxN
             }
         }
 
+        private void AddIndentBlockOperationsForFromClause(List<IndentBlockOperation> list, FromClauseSyntax fromClause)
+        {
+            // Only add the indent block operation if the 'in' keyword is present. Otherwise, we'll get the following:
+            //
+            //     from x
+            //         in args
+            //
+            // Rather than:
+            //
+            //     from x
+            //     in args
+            //
+            // However, we want to get the following result if the 'in' keyword is present to allow nested queries
+            // to be formatted properly.
+            //
+            //     from x in
+            //         args
+
+            if (fromClause.InKeyword.IsMissing)
+            {
+                return;
+            }
+
+            var baseToken = fromClause.FromKeyword;
+            var startToken = fromClause.Expression.GetFirstToken(includeZeroWidth: true);
+            var endToken = fromClause.Expression.GetLastToken(includeZeroWidth: true);
+
+            AddIndentBlockOperation(list, baseToken, startToken, endToken);
+        }
+
         public override void AddIndentBlockOperations(List<IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<IndentBlockOperation> nextOperation)
         {
             nextOperation.Invoke(list);
@@ -33,19 +63,15 @@ public override void AddIndentBlockOperations(List<IndentBlockOperation> list, S
             var queryExpression = node as QueryExpressionSyntax;
             if (queryExpression != null)
             {
-                var firstToken = queryExpression.FromClause.Expression.GetFirstToken(includeZeroWidth: true);
-                var lastToken = queryExpression.FromClause.Expression.GetLastToken(includeZeroWidth: true);
-                AddIndentBlockOperation(list, queryExpression.FromClause.FromKeyword, firstToken, lastToken);
+                AddIndentBlockOperationsForFromClause(list, queryExpression.FromClause);
 
-                for (int i = 0; i < queryExpression.Body.Clauses.Count; i++)
+                foreach (var queryClause in queryExpression.Body.Clauses)
                 {
                     // if it is nested query expression
-                    var fromClause = queryExpression.Body.Clauses[i] as FromClauseSyntax;
+                    var fromClause = queryClause as FromClauseSyntax;
                     if (fromClause != null)
                     {
-                        firstToken = fromClause.Expression.GetFirstToken(includeZeroWidth: true);
-                        lastToken = fromClause.Expression.GetLastToken(includeZeroWidth: true);
-                        AddIndentBlockOperation(list, fromClause.FromKeyword, firstToken, lastToken);
+                        AddIndentBlockOperationsForFromClause(list, fromClause);
                     }
                 }
 

src/Workspaces/VisualBasic/Portable/BasicWorkspace.vbproj

@@ -65,6 +65,7 @@
     <Compile Include="CaseCorrection\VisualBasicCaseCorrectionServiceFactory.vb" />
     <Compile Include="Classification\ClassificationHelpers.vb" />
     <Compile Include="Classification\Classifiers\AbstractSyntaxClassifier.vb" />
+    <Compile Include="Classification\Classifiers\IdentifierNameSyntaxClassifier.vb" />
     <Compile Include="Classification\Classifiers\ImportAliasClauseSyntaxClassifier.vb" />
     <Compile Include="Classification\Classifiers\NameSyntaxClassifier.vb" />
     <Compile Include="Classification\SyntaxClassifier.vb" />

src/Workspaces/VisualBasic/Portable/Classification/Classifiers/IdentifierNameSyntaxClassifier.vb

+' 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.Classification
+Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
+Imports Microsoft.CodeAnalysis.VisualBasic.Extensions.ContextQuery
+Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
+
+Namespace Microsoft.CodeAnalysis.VisualBasic.Classification.Classifiers
+    Friend Class IdentifierNameSyntaxClassifier
+        Inherits AbstractSyntaxClassifier
+
+        Private Const AwaitText = "Await"
+
+        Public Overrides ReadOnly Property SyntaxNodeTypes As IEnumerable(Of Type)
+            Get
+                Return {GetType(IdentifierNameSyntax)}
+            End Get
+        End Property
+
+        Public Overrides Function ClassifyNode(syntax As SyntaxNode, semanticModel As SemanticModel, cancellationToken As CancellationToken) As IEnumerable(Of ClassifiedSpan)
+            Dim identifierName = DirectCast(syntax, IdentifierNameSyntax)
+            Dim identifier = identifierName.Identifier
+            If CaseInsensitiveComparison.Equals(identifier.ValueText, AwaitText) Then
+                Dim symbolInfo = semanticModel.GetSymbolInfo(identifier)
+                If symbolInfo.GetAnySymbol() Is Nothing Then
+                    Return SpecializedCollections.SingletonEnumerable(New ClassifiedSpan(ClassificationTypeNames.Keyword, identifier.Span))
+                End If
+            End If
+
+            Return MyBase.ClassifyNode(syntax, semanticModel, cancellationToken)
+        End Function
+    End Class
+End Namespace
\ No newline at end of file

src/Workspaces/VisualBasic/Portable/Classification/SyntaxClassifier.vb

@@ -9,7 +9,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Classification
         Public ReadOnly DefaultSyntaxClassifiers As IEnumerable(Of ISyntaxClassifier) =
             ImmutableArray.Create(Of ISyntaxClassifier)(
                 New NameSyntaxClassifier(),
-                New ImportAliasClauseSyntaxClassifier()
-            )
+                New ImportAliasClauseSyntaxClassifier(),
+                New IdentifierNameSyntaxClassifier())
     End Module
 End Namespace

src/Workspaces/VisualBasic/Portable/Recommendations/VisualBasicRecommendationService.vb

@@ -138,24 +138,23 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Recommendations
             ' "Func(Of" tends to get in the way of typing "Function". Exclude System.Func from expression
             ' contexts, except within GetType
             If Not context.TargetToken.IsKind(SyntaxKind.OpenParenToken) OrElse
-               Not context.TargetToken.Parent.IsKind(SyntaxKind.GetTypeExpression) Then
+                    Not context.TargetToken.Parent.IsKind(SyntaxKind.GetTypeExpression) Then
 
-                symbols = symbols.Where(Function(s) Not IsSystemFunc(s))
+                symbols = symbols.Where(Function(s) Not IsInEligibleDelegate(s))
             End If
 
+
             ' Hide backing fields and events
             Return symbols.Where(Function(s) FilterEventsAndGeneratedSymbols(Nothing, s))
         End Function
 
-        Private Function IsSystemFunc(s As ISymbol) As Boolean
-            Dim namedTypeSymbol = TryCast(s, INamedTypeSymbol)
-            Return namedTypeSymbol IsNot Nothing AndAlso
-                    namedTypeSymbol.Name = "Func" AndAlso
-                    namedTypeSymbol.GetArity() > 0 AndAlso
-                    namedTypeSymbol.ContainingNamespace IsNot Nothing AndAlso
-                    namedTypeSymbol.ContainingNamespace.Name = "System" AndAlso
-                    namedTypeSymbol.ContainingNamespace.ContainingNamespace.IsGlobalNamespace
+        Private Function IsInEligibleDelegate(s As ISymbol) As Boolean
+            If s.IsDelegateType() Then
+                Dim typeSymbol = DirectCast(s, ITypeSymbol)
+                Return typeSymbol.SpecialType <> SpecialType.System_Delegate
+            End If
 
+            Return False
         End Function
 
         Private Function GetSymbolsForQualifiedNameSyntax(