Merge master to features/target-typing

.editorconfig

@@ -225,7 +225,8 @@ dotnet_diagnostic.RS0037.severity = none
 # warning RS0005: Do not use generic CodeAction.Create to create CodeAction
 dotnet_diagnostic.RS0005.severity = none
 
-[src/{Analyzers,CodeStyle,Features,Workspaces}/**/*.{cs,vb}]
+[src/{Analyzers,CodeStyle,Features,Workspaces,EditorFeatures}/**/*.{cs,vb}]
+
 # IDE0011: Add braces
 csharp_prefer_braces = when_multiline:warning
 # NOTE: We need the below severity entry for Add Braces due to https://github.com/dotnet/roslyn/issues/44201
@@ -266,4 +267,4 @@ dotnet_diagnostic.CA1822.severity = warning
 dotnet_diagnostic.IDE0007.severity = warning
 csharp_style_var_for_built_in_types = true:warning
 csharp_style_var_when_type_is_apparent = true:warning
-csharp_style_var_elsewhere = true:warning
+csharp_style_var_elsewhere = true:warning

NuGet.config

@@ -7,8 +7,6 @@
     <add key="dotnet-tools" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json" />
     <add key="dotnet5" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet5/nuget/v3/index.json" />
     <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
-    <!-- Microsoft.VisualStudio.* packages (e.g. Microsoft.VisualStudio.LanguageServer.Protocol.Extensions): https://github.com/dotnet/roslyn/issues/43242 -->
-    <add key="experimental-vs-packages" value="https://dotnet.myget.org/F/experimental-vs-packages/api/v3/index.json" />
     <!-- Microsoft.CodeAnalysis.Test.Resource.Proprietary -->
     <add key="roslyn-tools" value="https://dotnet.myget.org/F/roslyn-tools/api/v3/index.json" />
     <add key="roslyn-analyzers" value="https://dotnet.myget.org/F/roslyn-analyzers/api/v3/index.json" />

eng/Versions.props

@@ -34,7 +34,7 @@
     <CodeStyleAnalyzerVersion>3.7.0-3.20271.4</CodeStyleAnalyzerVersion>
     <VisualStudioEditorPackagesVersion>16.4.248</VisualStudioEditorPackagesVersion>
     <ILToolsPackageVersion>5.0.0-alpha1.19409.1</ILToolsPackageVersion>
-    <MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>16.7.29</MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>
+    <MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>16.8.5</MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>
   </PropertyGroup>
   <!--
     Dependency versions

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenInParametersTests.cs

@@ -1178,10 +1178,10 @@ static ref int M2(in int arg1, in (int Alice, int Bob) arg2)
 
             var comp = CreateCompilationWithMscorlib45(text, new[] { ValueTupleRef, SystemRuntimeFacadeRef });
             comp.VerifyDiagnostics(
-                // (18,20): error CS8410: Cannot return variable 'in int' by writable reference because it is a readonly variable
+                // (18,20): error CS8333: Cannot return variable 'in int' by writable reference because it is a readonly variable
                 //         return ref arg1;
                 Diagnostic(ErrorCode.ERR_RefReturnReadonlyNotField, "arg1").WithArguments("variable", "in int").WithLocation(18, 20),
-                // (23,20): error CS8411: Members of variable 'in (int Alice, int Bob)' cannot be returned by writable reference because it is a readonly variable
+                // (23,20): error CS8334: Members of variable 'in (int Alice, int Bob)' cannot be returned by writable reference because it is a readonly variable
                 //         return ref arg2.Alice;
                 Diagnostic(ErrorCode.ERR_RefReturnReadonlyNotField2, "arg2.Alice").WithArguments("variable", "in (int Alice, int Bob)").WithLocation(23, 20)
             );
@@ -1269,10 +1269,10 @@ static ref int M(in int arg1, in (int Alice, int Bob) arg2)
 
             var comp = CreateCompilationWithMscorlib45(text, new[] { ValueTupleRef, SystemRuntimeFacadeRef });
             comp.VerifyDiagnostics(
-                // (10,24): error CS8410: Cannot return variable 'in int' by writable reference because it is a readonly variable
+                // (10,24): error CS8333: Cannot return variable 'in int' by writable reference because it is a readonly variable
                 //             return ref arg1;
                 Diagnostic(ErrorCode.ERR_RefReturnReadonlyNotField, "arg1").WithArguments("variable", "in int").WithLocation(10, 24),
-                // (14,24): error CS8411: Members of variable 'in (int Alice, int Bob)' cannot be returned by writable reference because it is a readonly variable
+                // (14,24): error CS8334: Members of variable 'in (int Alice, int Bob)' cannot be returned by writable reference because it is a readonly variable
                 //             return ref arg2.Alice;
                 Diagnostic(ErrorCode.ERR_RefReturnReadonlyNotField2, "arg2.Alice").WithArguments("variable", "in (int Alice, int Bob)").WithLocation(14, 24)
             );
@@ -1388,10 +1388,10 @@ ref int M1(in int arg11, in (int Alice, int Bob) arg21)
 
             var comp = CreateCompilationWithMscorlib45(text, new[] { ValueTupleRef, SystemRuntimeFacadeRef });
             comp.VerifyDiagnostics(
-                // (12,28): error CS8410: Cannot return variable 'in int' by writable reference because it is a readonly variable
+                // (12,28): error CS8333: Cannot return variable 'in int' by writable reference because it is a readonly variable
                 //                 return ref arg11;
                 Diagnostic(ErrorCode.ERR_RefReturnReadonlyNotField, "arg11").WithArguments("variable", "in int").WithLocation(12, 28),
-                // (16,28): error CS8411: Members of variable 'in (int Alice, int Bob)' cannot be returned by writable reference because it is a readonly variable
+                // (16,28): error CS8334: Members of variable 'in (int Alice, int Bob)' cannot be returned by writable reference because it is a readonly variable
                 //                 return ref arg21.Alice;
                 Diagnostic(ErrorCode.ERR_RefReturnReadonlyNotField2, "arg21.Alice").WithArguments("variable", "in (int Alice, int Bob)").WithLocation(16, 28)
                 );

src/EditorFeatures/CSharp.Wpf/Completion/CompletionProviders/CSharpReplCommandCompletionProvider.cs

@@ -46,7 +46,7 @@ protected override string GetCompletionString(string commandName)
         private static readonly Regex s_referenceRegex = new Regex(@"\s*#\s*r\s+", RegexOptions.Compiled);
         private static readonly Regex s_loadCommandRegex = new Regex(@"#load\s+", RegexOptions.Compiled);
 
-        private bool IsReplCommandLocation(SnapshotPoint characterPoint)
+        private static bool IsReplCommandLocation(SnapshotPoint characterPoint)
         {
             // TODO(cyrusn): We don't need to do this textually.  We could just defer this to
             // IsTriggerCharacter and just check the syntax tree.

src/EditorFeatures/CSharp.Wpf/Interactive/CSharpSendToInteractiveSubmissionProvider.cs

@@ -28,14 +28,14 @@ public CSharpSendToInteractiveSubmissionProvider()
         protected override bool CanParseSubmission(string code)
         {
             ParseOptions options = CSharpParseOptions.Default.WithKind(SourceCodeKind.Script);
-            SyntaxTree tree = SyntaxFactory.ParseSyntaxTree(code, options);
+            var tree = SyntaxFactory.ParseSyntaxTree(code, options);
             return tree.HasCompilationUnitRoot &&
                 !tree.GetDiagnostics().Any(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
         }
 
         protected override IEnumerable<TextSpan> GetExecutableSyntaxTreeNodeSelection(TextSpan selectionSpan, SyntaxNode root)
         {
-            SyntaxNode expandedNode = GetSyntaxNodeForSubmission(selectionSpan, root);
+            var expandedNode = GetSyntaxNodeForSubmission(selectionSpan, root);
             return expandedNode != null
                 ? new TextSpan[] { expandedNode.Span }
                 : Array.Empty<TextSpan>();
@@ -46,7 +46,7 @@ protected override IEnumerable<TextSpan> GetExecutableSyntaxTreeNodeSelection(Te
         /// </summary>
         /// <param name="selectionSpan">Selection that user has originally made.</param>
         /// <param name="root">Root of the syntax tree.</param>
-        private SyntaxNode GetSyntaxNodeForSubmission(TextSpan selectionSpan, SyntaxNode root)
+        private static SyntaxNode GetSyntaxNodeForSubmission(TextSpan selectionSpan, SyntaxNode root)
         {
             GetSelectedTokens(selectionSpan, root, out var startToken, out var endToken);
 
@@ -117,7 +117,7 @@ private static bool IsSubmissionNode(SyntaxNode node)
                 || node.IsKind(SyntaxKind.UsingDirective);
         }
 
-        private void GetSelectedTokens(
+        private static void GetSelectedTokens(
             TextSpan selectionSpan,
             SyntaxNode root,
             out SyntaxToken startToken,

src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler.cs

@@ -151,22 +151,22 @@ protected override string GetEndingString(Document document, int position, Cance
             return null;
         }
 
-        private SyntaxNode ParseNode(SyntaxTree tree, SyntaxNode owningNode, string textToParse)
+        private static SyntaxNode ParseNode(SyntaxTree tree, SyntaxNode owningNode, string textToParse)
             => owningNode switch
             {
-                BaseFieldDeclarationSyntax n => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options),
-                BaseMethodDeclarationSyntax n => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options),
-                BasePropertyDeclarationSyntax n => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options),
-                StatementSyntax n => SyntaxFactory.ParseStatement(textToParse, options: (CSharpParseOptions)tree.Options),
-                UsingDirectiveSyntax n => SyntaxFactory.ParseCompilationUnit(textToParse, options: (CSharpParseOptions)tree.Options),
+                BaseFieldDeclarationSyntax _ => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options),
+                BaseMethodDeclarationSyntax _ => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options),
+                BasePropertyDeclarationSyntax _ => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options),
+                StatementSyntax _ => SyntaxFactory.ParseStatement(textToParse, options: (CSharpParseOptions)tree.Options),
+                UsingDirectiveSyntax _ => SyntaxFactory.ParseCompilationUnit(textToParse, options: (CSharpParseOptions)tree.Options),
 
                 _ => (SyntaxNode)null,
             };
 
         /// <summary>
         /// wrap field in type
         /// </summary>
-        private string WrapInType(string textToParse)
+        private static string WrapInType(string textToParse)
             => "class C { " + textToParse + " }";
 
         /// <summary>

src/EditorFeatures/CSharp/AutomaticCompletion/Sessions/CurlyBraceCompletionSession.cs

@@ -107,13 +107,13 @@ private static bool ContainsOnlyWhitespace(IBraceCompletionSession session)
             return true;
         }
 
-        private IEnumerable<AbstractFormattingRule> GetFormattingRules(Document document)
+        private static IEnumerable<AbstractFormattingRule> GetFormattingRules(Document document)
         {
             var indentStyle = document.GetOptionsAsync(CancellationToken.None).WaitAndGetResult_CanCallOnBackground(CancellationToken.None).GetOption(FormattingOptions.SmartIndent);
             return SpecializedCollections.SingletonEnumerable<AbstractFormattingRule>(BraceCompletionFormattingRule.ForIndentStyle(indentStyle)).Concat(Formatter.GetDefaultFormattingRules(document));
         }
 
-        private void FormatTrackingSpan(IBraceCompletionSession session, bool shouldHonorAutoFormattingOnCloseBraceOption, IEnumerable<AbstractFormattingRule> rules = null)
+        private static void FormatTrackingSpan(IBraceCompletionSession session, bool shouldHonorAutoFormattingOnCloseBraceOption, IEnumerable<AbstractFormattingRule> rules = null)
         {
             if (!session.SubjectBuffer.GetFeatureOnOffOption(FeatureOnOffOptions.AutoFormattingOnCloseBrace) && shouldHonorAutoFormattingOnCloseBraceOption)
             {

src/EditorFeatures/CSharp/AutomaticCompletion/Sessions/LessAndGreaterThanCompletionSession.cs

@@ -44,7 +44,7 @@ public override bool CheckOpeningPoint(IBraceCompletionSession session, Cancella
             return true;
         }
 
-        private bool PossibleTypeArgument(ITextSnapshot snapshot, SyntaxToken token, CancellationToken cancellationToken)
+        private static bool PossibleTypeArgument(ITextSnapshot snapshot, SyntaxToken token, CancellationToken cancellationToken)
         {
             // type argument can be easily ambiguous with normal < operations
             if (!(token.Parent is BinaryExpressionSyntax node) || node.Kind() != SyntaxKind.LessThanExpression || node.OperatorToken != token)

src/EditorFeatures/CSharp/BlockCommentEditing/BlockCommentEditingCommandHandler.cs

@@ -79,7 +79,7 @@ private bool TryHandleReturnKey(ITextBuffer subjectBuffer, ITextView textView)
             return true;
         }
 
-        private Span GetReplacementSpan(SnapshotPoint caretPosition)
+        private static Span GetReplacementSpan(SnapshotPoint caretPosition)
         {
             // We want to replace all the whitespace following the caret.  This is standard <enter> behavior in VS that
             // we want to mimic.
@@ -92,7 +92,7 @@ private Span GetReplacementSpan(SnapshotPoint caretPosition)
             return Span.FromBounds(start, end);
         }
 
-        private string? GetTextToInsert(SnapshotPoint caretPosition)
+        private static string? GetTextToInsert(SnapshotPoint caretPosition)
         {
             var currentLine = caretPosition.GetContainingLine();
             var firstNonWhitespacePosition = currentLine.GetFirstNonWhitespacePosition() ?? -1;

src/EditorFeatures/CSharp/DecompiledSource/CSharpDecompiledSourceFormattingRule.cs

@@ -25,7 +25,7 @@ private CSharpDecompiledSourceFormattingRule()
             return operation ?? nextOperation.Invoke(in previousToken, in currentToken);
         }
 
-        private AdjustNewLinesOperation? GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken)
+        private static AdjustNewLinesOperation? GetAdjustNewLinesOperation(SyntaxToken previousToken, SyntaxToken currentToken)
         {
             // To help code not look too tightly packed, we place a blank line after every statement that ends with a
             // `}` (unless it's also followed by another `}`).

src/EditorFeatures/CSharp/DecompiledSource/CSharpDecompiledSourceService.cs

@@ -97,7 +97,7 @@ public static async Task<Document> FormatDocumentAsync(Document document, Cancel
             return formattedDoc;
         }
 
-        private Document PerformDecompilation(Document document, string fullName, Compilation compilation, string assemblyLocation)
+        private static Document PerformDecompilation(Document document, string fullName, Compilation compilation, string assemblyLocation)
         {
             // Load the assembly.
             var file = new PEFile(assemblyLocation, PEStreamOptions.PrefetchEntireImage);
@@ -122,7 +122,7 @@ private Document PerformDecompilation(Document document, string fullName, Compil
             return document.WithText(SourceText.From(text));
         }
 
-        private async Task<Document> AddAssemblyInfoRegionAsync(Document document, ISymbol symbol, CancellationToken cancellationToken)
+        private static async Task<Document> AddAssemblyInfoRegionAsync(Document document, ISymbol symbol, CancellationToken cancellationToken)
         {
             var assemblyInfo = MetadataAsSourceHelpers.GetAssemblyInfo(symbol.ContainingAssembly);
             var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
@@ -148,7 +148,7 @@ private async Task<Document> AddAssemblyInfoRegionAsync(Document document, ISymb
             return document.WithSyntaxRoot(newRoot);
         }
 
-        private async Task<Document> ConvertDocCommentsToRegularCommentsAsync(Document document, IDocumentationCommentFormattingService docCommentFormattingService, CancellationToken cancellationToken)
+        private static async Task<Document> ConvertDocCommentsToRegularCommentsAsync(Document document, IDocumentationCommentFormattingService docCommentFormattingService, CancellationToken cancellationToken)
         {
             var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
@@ -157,7 +157,7 @@ private async Task<Document> ConvertDocCommentsToRegularCommentsAsync(Document d
             return document.WithSyntaxRoot(newSyntaxRoot);
         }
 
-        private string GetFullReflectionName(INamedTypeSymbol containingType)
+        private static string GetFullReflectionName(INamedTypeSymbol containingType)
         {
             var stack = new Stack<string>();
             stack.Push(containingType.MetadataName);

src/EditorFeatures/CSharp/DocumentationComments/DocumentationCommentCommandHandler.cs

@@ -220,7 +220,7 @@ protected override bool IsSingleExteriorTrivia(DocumentationCommentTriviaSyntax
                 && lastTextToken.TrailingTrivia.Count == 0;
         }
 
-        private IList<SyntaxToken> GetTextTokensFollowingExteriorTrivia(XmlTextSyntax xmlText)
+        private static IList<SyntaxToken> GetTextTokensFollowingExteriorTrivia(XmlTextSyntax xmlText)
         {
             var result = new List<SyntaxToken>();
 

src/EditorFeatures/CSharp/DocumentationComments/XmlTagCompletionCommandHandler.cs

@@ -77,7 +77,7 @@ protected override void TryCompleteTag(ITextView textView, ITextBuffer subjectBu
             }
         }
 
-        private bool HasFollowingEndTagTrivia(XmlElementSyntax parentElement, SyntaxToken lessThanSlashToken)
+        private static bool HasFollowingEndTagTrivia(XmlElementSyntax parentElement, SyntaxToken lessThanSlashToken)
         {
             var expectedEndTagText = "</" + parentElement.StartTag.Name.LocalName.ValueText + ">";
 
@@ -113,7 +113,7 @@ private bool HasUnmatchedIdenticalParent(XmlElementStartTagSyntax parentStartTag
             return false;
         }
 
-        private bool HasMatchingEndTag(XmlElementStartTagSyntax parentStartTag)
+        private static bool HasMatchingEndTag(XmlElementStartTagSyntax parentStartTag)
         {
             if (parentStartTag == null)
             {