Merge pull request #42893 from sharwell/ancestor-or-self-arg

Add FirstAncestorOrSelf extension with an argument

Author: sharwell

src/Analyzers/Core/CodeFixes/ConvertAnonymousTypeToTuple/AbstractConvertAnonymousTypeToTupleCodeFixProvider.cs

@@ -73,7 +73,7 @@ private async Task FixInCurrentMemberAsync(
             }
 
             var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
-            var containingMember = creationNode.FirstAncestorOrSelf<SyntaxNode>(syntaxFacts.IsMethodLevelMember) ?? creationNode;
+            var containingMember = creationNode.FirstAncestorOrSelf<SyntaxNode, ISyntaxFactsService>((node, syntaxFacts) => syntaxFacts.IsMethodLevelMember(node), syntaxFacts) ?? creationNode;
 
             var childCreationNodes = containingMember.DescendantNodesAndSelf()
                                                      .OfType<TAnonymousObjectCreationExpressionSyntax>();

src/Analyzers/Core/CodeFixes/RemoveUnusedParametersAndValues/AbstractRemoveUnusedValuesCodeFixProvider.cs

@@ -621,10 +621,11 @@ TLocalDeclarationStatementSyntax CreateLocalDeclarationStatement(ITypeSymbol typ
             void InsertLocalDeclarationStatement(TLocalDeclarationStatementSyntax declarationStatement, SyntaxNode node)
             {
                 // Find the correct place to insert the given declaration statement based on the node's ancestors.
-                var insertionNode = node.FirstAncestorOrSelf<SyntaxNode>(n => n.Parent is TSwitchCaseBlockSyntax ||
+                var insertionNode = node.FirstAncestorOrSelf<SyntaxNode, ISyntaxFactsService>((n, syntaxFacts) => n.Parent is TSwitchCaseBlockSyntax ||
                                                                               syntaxFacts.IsExecutableBlock(n.Parent) &&
                                                                               !(n is TCatchStatementSyntax) &&
-                                                                              !(n is TCatchBlockSyntax));
+                                                                              !(n is TCatchBlockSyntax),
+                                                                              syntaxFacts);
                 if (insertionNode is TSwitchCaseLabelOrClauseSyntax)
                 {
                     InsertAtStartOfSwitchCaseBlockForDeclarationInCaseLabelOrClause(insertionNode.GetAncestor<TSwitchCaseBlockSyntax>(), editor, declarationStatement);

src/CodeStyle/Core/Analyzers/Extensions/CodeStyleSyntaxNodeExtensions.cs

@@ -0,0 +1,50 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal static class CodeStyleSyntaxNodeExtensions
+    {
+        /// <summary>
+        /// Gets the first node of type TNode that matches the predicate.
+        /// </summary>
+        /// <remarks>
+        /// This method was added to <see cref="SyntaxNode"/> as a public API. This extension method can be removed once
+        /// the code style layer is updated to reference a version of Roslyn that includes it. It will be easy to
+        /// identify since this method will show 0 references once the switch occurs.
+        /// </remarks>
+        internal static TNode? FirstAncestorOrSelf<TNode, TArg>(this SyntaxNode? node, Func<TNode, TArg, bool> predicate, TArg argument, bool ascendOutOfTrivia = true)
+            where TNode : SyntaxNode
+        {
+            for (; node != null; node = GetParent(node, ascendOutOfTrivia))
+            {
+                if (node is TNode tnode && predicate(tnode, argument))
+                {
+                    return tnode;
+                }
+            }
+
+            return null;
+        }
+
+        private static SyntaxNode? GetParent(SyntaxNode node, bool ascendOutOfTrivia)
+        {
+            var parent = node.Parent;
+            if (parent == null && ascendOutOfTrivia)
+            {
+                var structuredTrivia = node as IStructuredTriviaSyntax;
+                if (structuredTrivia != null)
+                {
+                    parent = structuredTrivia.ParentTrivia.Token.Parent;
+                }
+            }
+
+            return parent;
+        }
+    }
+}

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

@@ -23,6 +23,7 @@ Microsoft.CodeAnalysis.SourceGeneratorContext.CancellationToken.get -> System.Th
 Microsoft.CodeAnalysis.SourceGeneratorContext.Compilation.get -> Microsoft.CodeAnalysis.Compilation
 Microsoft.CodeAnalysis.SourceGeneratorContext.ReportDiagnostic(Microsoft.CodeAnalysis.Diagnostic diagnostic) -> void
 Microsoft.CodeAnalysis.SourceGeneratorContext.SyntaxReceiver.get -> Microsoft.CodeAnalysis.ISyntaxReceiver
+Microsoft.CodeAnalysis.SyntaxNode.FirstAncestorOrSelf<TNode, TArg>(System.Func<TNode, TArg, bool> predicate, TArg argument, bool ascendOutOfTrivia = true) -> TNode
 Microsoft.CodeAnalysis.SyntaxReceiverCreator
 override Microsoft.CodeAnalysis.Diagnostics.AnalyzerFileReference.GetGenerators() -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ISourceGenerator>
 virtual Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGenerators() -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ISourceGenerator>

src/Compilers/Core/Portable/Syntax/SyntaxNode.cs

@@ -7,6 +7,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -724,6 +725,24 @@ public IEnumerable<SyntaxNode> AncestorsAndSelf(bool ascendOutOfTrivia = true)
             return null;
         }
 
+        /// <summary>
+        /// Gets the first node of type TNode that matches the predicate.
+        /// </summary>
+        [SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "Required for consistent API usage patterns.")]
+        public TNode? FirstAncestorOrSelf<TNode, TArg>(Func<TNode, TArg, bool> predicate, TArg argument, bool ascendOutOfTrivia = true)
+            where TNode : SyntaxNode
+        {
+            for (var node = this; node != null; node = GetParent(node, ascendOutOfTrivia))
+            {
+                if (node is TNode tnode && predicate(tnode, argument))
+                {
+                    return tnode;
+                }
+            }
+
+            return null;
+        }
+
         /// <summary>
         /// Gets a list of descendant nodes in prefix document order.
         /// </summary>
@@ -827,7 +846,7 @@ public SyntaxNode FindNode(TextSpan span, bool findInsideTrivia = false, bool ge
 
             var node = FindToken(span.Start, findInsideTrivia)
                 .Parent
-                !.FirstAncestorOrSelf<SyntaxNode>(a => a.FullSpan.Contains(span));
+                !.FirstAncestorOrSelf<SyntaxNode, TextSpan>((a, span) => a.FullSpan.Contains(span), span);
 
             RoslynDebug.Assert(node is object);
             SyntaxNode? cuRoot = node.SyntaxTree?.GetRoot();

src/EditorFeatures/Core/Implementation/Peek/PeekHelpers.cs

@@ -56,12 +56,12 @@ internal static LinePositionSpan GetEntityOfInterestSpan(ISymbol symbol, Workspa
                 case SymbolKind.Field:
                 case SymbolKind.Method:
                 case SymbolKind.Property:
-                    node = node.FirstAncestorOrSelf<SyntaxNode>(syntaxFactsService.IsMethodLevelMember) ?? node;
+                    node = node.FirstAncestorOrSelf<SyntaxNode, ISyntaxFactsService>((node, syntaxFactsService) => syntaxFactsService.IsMethodLevelMember(node), syntaxFactsService) ?? node;
                     break;
 
                 case SymbolKind.NamedType:
                 case SymbolKind.Namespace:
-                    node = node.FirstAncestorOrSelf<SyntaxNode>(syntaxFactsService.IsTopLevelNodeWithMembers) ?? node;
+                    node = node.FirstAncestorOrSelf<SyntaxNode, ISyntaxFactsService>((node, syntaxFactsService) => syntaxFactsService.IsTopLevelNodeWithMembers(node), syntaxFactsService) ?? node;
                     break;
             }
 

src/Features/CSharp/Portable/SignatureHelp/ElementAccessExpressionSignatureHelpProvider.cs

@@ -386,8 +386,8 @@ internal static bool TryGetSyntax(SyntaxNode root, int position, ISyntaxFactsSer
                 if (CommonSignatureHelpUtilities.TryGetSyntax(root, position, syntaxFacts, triggerReason, IsTriggerToken, IsArgumentListToken, cancellationToken, out ElementBindingExpressionSyntax elementBindingExpression))
                 {
                     // Find the first conditional access expression that starts left of our open bracket
-                    var conditionalAccess = elementBindingExpression.FirstAncestorOrSelf<ConditionalAccessExpressionSyntax>(
-                        c => c.SpanStart < elementBindingExpression.SpanStart);
+                    var conditionalAccess = elementBindingExpression.FirstAncestorOrSelf<ConditionalAccessExpressionSyntax, ElementBindingExpressionSyntax>(
+                        (c, elementBindingExpression) => c.SpanStart < elementBindingExpression.SpanStart, elementBindingExpression);
 
                     identifier = conditionalAccess.Expression;
                     openBrace = elementBindingExpression.ArgumentList.OpenBracketToken;

src/Features/Core/Portable/AddImport/AbstractAddImportFeatureService.cs

@@ -552,6 +552,6 @@ protected bool AncestorOrSelfIsAwaitExpression(ISyntaxFacts syntaxFactsService,
             => FirstAwaitExpressionAncestor(syntaxFactsService, node) != null;
 
         private SyntaxNode FirstAwaitExpressionAncestor(ISyntaxFacts syntaxFactsService, SyntaxNode node)
-            => node.FirstAncestorOrSelf<SyntaxNode>(n => syntaxFactsService.IsAwaitExpression(n));
+            => node.FirstAncestorOrSelf<SyntaxNode, ISyntaxFacts>((n, syntaxFactsService) => syntaxFactsService.IsAwaitExpression(n), syntaxFactsService);
     }
 }

src/Features/Core/Portable/ConvertAnonymousTypeToClass/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs

@@ -118,7 +118,7 @@ private async Task<Document> ConvertToClassAsync(Document document, TextSpan spa
             var editor = new SyntaxEditor(root, generator);
 
             var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
-            var containingMember = anonymousObject.FirstAncestorOrSelf<SyntaxNode>(syntaxFacts.IsMethodLevelMember) ?? anonymousObject;
+            var containingMember = anonymousObject.FirstAncestorOrSelf<SyntaxNode, ISyntaxFactsService>((node, syntaxFacts) => syntaxFacts.IsMethodLevelMember(node), syntaxFacts) ?? anonymousObject;
 
             // Next, go and update any references to these anonymous type properties to match
             // the new PascalCased name we've picked for the new properties that will go in

src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs

@@ -439,7 +439,7 @@ private static ImmutableArray<DocumentToUpdate> GetDocumentsToUpdateForContainin
             Document document, SyntaxNode tupleExprOrTypeNode)
         {
             var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
-            var containingMember = tupleExprOrTypeNode.FirstAncestorOrSelf<SyntaxNode>(syntaxFacts.IsMethodLevelMember) ?? tupleExprOrTypeNode;
+            var containingMember = tupleExprOrTypeNode.FirstAncestorOrSelf<SyntaxNode, ISyntaxFactsService>((node, syntaxFacts) => syntaxFacts.IsMethodLevelMember(node), syntaxFacts) ?? tupleExprOrTypeNode;
 
             return ImmutableArray.Create(new DocumentToUpdate(
                 document, ImmutableArray.Create(containingMember)));