Merge pull request #45911 from dotnet/merges/master-to-features/target-typing

Merge master to features/target-typing

Author: msftbot[bot]

.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;