Revert removal of special handling of ArgService (reason #37295)

src/Features/CSharp/Portable/CodeRefactorings/CSharpRefactoringHelpersService.cs

@@ -11,7 +11,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.CodeRefactorings
 {
     [ExportLanguageService(typeof(IRefactoringHelpersService), LanguageNames.CSharp), Shared]
-    internal class CSharpRefactoringHelpersService : AbstractRefactoringHelpersService<ExpressionSyntax>
+    internal class CSharpRefactoringHelpersService : AbstractRefactoringHelpersService<ExpressionSyntax, ArgumentSyntax>
     {
         protected override IEnumerable<SyntaxNode> ExtractNodesSimple(SyntaxNode node, ISyntaxFactsService syntaxFacts)
         {

src/Features/CSharp/Portable/NameTupleElement/CSharpNameTupleElementCodeRefactoringProvider.cs

@@ -11,7 +11,7 @@ namespace Microsoft.CodeAnalysis.CSharp.NameTupleElement
 {
     [ExtensionOrder(After = PredefinedCodeRefactoringProviderNames.IntroduceVariable)]
     [ExportCodeRefactoringProvider(LanguageNames.CSharp, Name = nameof(CSharpNameTupleElementCodeRefactoringProvider)), Shared]
-    internal class CSharpNameTupleElementCodeRefactoringProvider : AbstractNameTupleElementCodeRefactoringProvider<ArgumentSyntax, TupleExpressionSyntax, ExpressionSyntax>
+    internal class CSharpNameTupleElementCodeRefactoringProvider : AbstractNameTupleElementCodeRefactoringProvider<ArgumentSyntax, TupleExpressionSyntax>
     {
         [ImportingConstructor]
         public CSharpNameTupleElementCodeRefactoringProvider()

src/Features/CSharp/Portable/UseNamedArguments/CSharpUseNamedArgumentsCodeRefactoringProvider.cs

@@ -15,7 +15,7 @@ namespace Microsoft.CodeAnalysis.CSharp.UseNamedArguments
     [ExportCodeRefactoringProvider(LanguageNames.CSharp, Name = nameof(CSharpUseNamedArgumentsCodeRefactoringProvider)), Shared]
     internal class CSharpUseNamedArgumentsCodeRefactoringProvider : AbstractUseNamedArgumentsCodeRefactoringProvider
     {
-        private abstract class BaseAnalyzer<TSyntax, TSyntaxList> : Analyzer<TSyntax, TSyntax, TSyntaxList, ExpressionSyntax>
+        private abstract class BaseAnalyzer<TSyntax, TSyntaxList> : Analyzer<TSyntax, TSyntax, TSyntaxList>
             where TSyntax : SyntaxNode
             where TSyntaxList : SyntaxNode
         {

src/Features/Core/Portable/CodeRefactorings/AbstractRefactoringHelpersService.cs

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.LanguageServices;
@@ -14,8 +13,9 @@
 
 namespace Microsoft.CodeAnalysis.CodeRefactorings
 {
-    internal abstract class AbstractRefactoringHelpersService<TExpressionSyntax> : IRefactoringHelpersService
+    internal abstract class AbstractRefactoringHelpersService<TExpressionSyntax, TArgumentSyntax> : IRefactoringHelpersService
         where TExpressionSyntax : SyntaxNode
+        where TArgumentSyntax : SyntaxNode
     {
         public async Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode>(
             Document document, TextSpan selectionRaw,
@@ -105,9 +105,10 @@ internal abstract class AbstractRefactoringHelpersService<TExpressionSyntax> : I
                     AddNodesForTokenToLeft(syntaxFacts, relevantNodesBuilder, location, tokenToLeft, cancellationToken);
 
                     // If the wanted node is an expression syntax -> traverse upwards even if location is deep within a SyntaxNode.
-                    if (typeof(TSyntaxNode).IsSubclassOf(typeof(TExpressionSyntax)) || typeof(TSyntaxNode) == typeof(TExpressionSyntax))
+                    // We want to treat more types like expressions, e.g.: ArgumentSyntax should still trigger even if deep-in.
+                    if (IsWantedTypeExpressionLike<TSyntaxNode>())
                     {
-                        await AddNodesDeepInExpression(document, location, relevantNodesBuilder, cancellationToken).ConfigureAwait(false);
+                        await AddNodesDeepIn(document, location, relevantNodesBuilder, cancellationToken).ConfigureAwait(false);
                     }
                 }
 
@@ -119,6 +120,20 @@ internal abstract class AbstractRefactoringHelpersService<TExpressionSyntax> : I
             }
         }
 
+        private static bool IsWantedTypeExpressionLike<TSyntaxNode>() where TSyntaxNode : SyntaxNode
+        {
+            var wantedType = typeof(TSyntaxNode);
+            var expressionType = typeof(TExpressionSyntax);
+            var argumentType = typeof(TArgumentSyntax);
+
+            return IsAEqualOrSubclassOfB(wantedType, expressionType) || IsAEqualOrSubclassOfB(wantedType, argumentType);
+
+            static bool IsAEqualOrSubclassOfB(Type a, Type b)
+            {
+                return a.IsSubclassOf(b) || a == b;
+            }
+        }
+
         private async Task<(SyntaxToken tokenToRightOrIn, SyntaxToken tokenToLeft, int location)> GetTokensToRightOrInToLeftAndUpdatedLocation(
             Document document,
             SyntaxNode root,
@@ -404,7 +419,7 @@ protected virtual IEnumerable<SyntaxNode> ExtractNodesInHeader(SyntaxNode root,
             }
         }
 
-        protected virtual async Task AddNodesDeepInExpression<TSyntaxNode>(
+        protected virtual async Task AddNodesDeepIn<TSyntaxNode>(
             Document document, int position,
             ArrayBuilder<TSyntaxNode> relevantNodesBuilder,
             CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode

src/Features/Core/Portable/NameTupleElement/AbstractNameTupleElementCodeRefactoringProvider.cs

@@ -12,10 +12,9 @@
 
 namespace Microsoft.CodeAnalysis.NameTupleElement
 {
-    abstract class AbstractNameTupleElementCodeRefactoringProvider<TArgumentSyntax, TTupleExpressionSyntax, TExpresionSyntax> : CodeRefactoringProvider
+    abstract class AbstractNameTupleElementCodeRefactoringProvider<TArgumentSyntax, TTupleExpressionSyntax> : CodeRefactoringProvider
         where TArgumentSyntax : SyntaxNode
-        where TExpresionSyntax : SyntaxNode
-        where TTupleExpressionSyntax : TExpresionSyntax
+        where TTupleExpressionSyntax : SyntaxNode
     {
         protected abstract bool IsCloseParenOrComma(SyntaxToken token);
         protected abstract TArgumentSyntax WithName(TArgumentSyntax argument, string argumentName);
@@ -45,9 +44,8 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
             }
 
             var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
-            var expressions = await document.TryGetRelevantNodesAsync<TExpresionSyntax>(span, cancellationToken).ConfigureAwait(false);
-            var argument = expressions.FirstOrDefault(
-                n => n.Parent is TArgumentSyntax && n.Parent.Parent is TTupleExpressionSyntax)?.Parent as TArgumentSyntax;
+            var potentialArguments = await document.TryGetRelevantNodesAsync<TArgumentSyntax>(span, cancellationToken).ConfigureAwait(false);
+            var argument = potentialArguments.FirstOrDefault(n => n?.Parent is TTupleExpressionSyntax);
             if (argument == null || !syntaxFacts.IsSimpleArgument(argument))
             {
                 return default;
@@ -63,7 +61,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
             }
 
             syntaxFacts.GetPartsOfTupleExpression<TArgumentSyntax>(tuple, out _, out var arguments, out _);
-            var argumentIndex = arguments.IndexOf(argument);
+            var argumentIndex = potentialArguments.IndexOf(argument);
             var elements = tupleType.TupleElements;
             if (elements.IsDefaultOrEmpty || argumentIndex >= elements.Length)
             {

src/Features/Core/Portable/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs

@@ -20,19 +20,17 @@ protected interface IAnalyzer
             Task ComputeRefactoringsAsync(CodeRefactoringContext context, SyntaxNode root);
         }
 
-        protected abstract class Analyzer<TBaseArgumentSyntax, TSimpleArgumentSyntax, TArgumentListSyntax, TExpressionSyntax> : IAnalyzer
+        protected abstract class Analyzer<TBaseArgumentSyntax, TSimpleArgumentSyntax, TArgumentListSyntax> : IAnalyzer
             where TBaseArgumentSyntax : SyntaxNode
             where TSimpleArgumentSyntax : TBaseArgumentSyntax
             where TArgumentListSyntax : SyntaxNode
-            where TExpressionSyntax : SyntaxNode
         {
             public async Task ComputeRefactoringsAsync(
                 CodeRefactoringContext context, SyntaxNode root)
             {
                 var (document, textSpan, cancellationToken) = context;
 
-                var expressions = await context.TryGetSelectedNodesAsync<TExpressionSyntax>().ConfigureAwait(false);
-                var argument = expressions.FirstOrDefault(n => n.Parent is TSimpleArgumentSyntax)?.Parent as TSimpleArgumentSyntax;
+                var argument = await context.TryGetSelectedNodeAsync<TBaseArgumentSyntax>().ConfigureAwait(false) as TSimpleArgumentSyntax;
                 if (argument == null)
                 {
                     return;

src/Features/VisualBasic/Portable/CodeRefactorings/VisualBasicRefactoringHelpersService.vb

@@ -9,7 +9,7 @@ Imports Microsoft.CodeAnalysis.LanguageServices
 Namespace Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings
     <ExportLanguageService(GetType(IRefactoringHelpersService), LanguageNames.VisualBasic), [Shared]>
     Friend Class VisualBasicRefactoringHelpersService
-        Inherits AbstractRefactoringHelpersService(Of ExpressionSyntax)
+        Inherits AbstractRefactoringHelpersService(Of ExpressionSyntax, ArgumentSyntax)
 
         Protected Overrides Iterator Function ExtractNodesSimple(node As SyntaxNode, syntaxFacts As ISyntaxFactsService) As IEnumerable(Of SyntaxNode)
             For Each baseExtraction In MyBase.ExtractNodesSimple(node, syntaxFacts)

src/Features/VisualBasic/Portable/NameTupleElement/VisualBasicNameTupleElementCodeRefactoringProvider.vb

@@ -9,7 +9,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.NameTupleElement
     <ExtensionOrder(After:=PredefinedCodeRefactoringProviderNames.IntroduceVariable)>
     <ExportCodeRefactoringProvider(LanguageNames.VisualBasic, Name:=NameOf(VisualBasicNameTupleElementCodeRefactoringProvider)), [Shared]>
     Friend Class VisualBasicNameTupleElementCodeRefactoringProvider
-        Inherits AbstractNameTupleElementCodeRefactoringProvider(Of SimpleArgumentSyntax, TupleExpressionSyntax, ExpressionSyntax)
+        Inherits AbstractNameTupleElementCodeRefactoringProvider(Of SimpleArgumentSyntax, TupleExpressionSyntax)
 
         <ImportingConstructor>
         Public Sub New()

src/Features/VisualBasic/Portable/UseNamedArguments/VisualBasicUseNamedArgumentsCodeRefactoringProvider.vb

@@ -14,7 +14,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseNamedArguments
         Inherits AbstractUseNamedArgumentsCodeRefactoringProvider
 
         Private Class ArgumentAnalyzer
-            Inherits Analyzer(Of ArgumentSyntax, SimpleArgumentSyntax, ArgumentListSyntax, ExpressionSyntax)
+            Inherits Analyzer(Of ArgumentSyntax, SimpleArgumentSyntax, ArgumentListSyntax)
 
             Protected Overrides Function IsPositionalArgument(argument As SimpleArgumentSyntax) As Boolean
                 Return argument.NameColonEquals Is Nothing