Parent

AddImport\CSharpAddImportFeatureService.cs (12)

39=> node.GetAncestor<UsingDirectiveSyntax>()?.Parent is CompilationUnitSyntax; 55if (node.Parent is not MemberAccessExpressionSyntax(SyntaxKind.SimpleMemberAccessExpression) simpleMemberAccess || 75else if (node.Parent.IsKind(SyntaxKind.CollectionInitializerExpression)) 94var memberAccessName = (node.Parent as MemberAccessExpressionSyntax)?.Name; 95var conditionalAccessName = (((node.Parent as ConditionalAccessExpressionSyntax)?.WhenNotNull as InvocationExpressionSyntax)?.Expression as MemberBindingExpressionSyntax)?.Name; 126if (nameNode?.Parent?.Kind() is not SyntaxKind.SimpleMemberAccessExpression and not SyntaxKind.MemberBindingExpression) 129var memberAccess = nameNode.Parent as MemberAccessExpressionSyntax; 130var memberBinding = nameNode.Parent as MemberBindingExpressionSyntax; 131if (memberAccess?.Parent?.Kind() is SyntaxKind.SimpleMemberAccessExpression or SyntaxKind.ElementAccessExpression || 132memberBinding?.Parent?.Kind() is SyntaxKind.SimpleMemberAccessExpression or SyntaxKind.ElementAccessExpression) 170node.AncestorsAndSelf().Any(n => n is QueryExpressionSyntax && !(n.Parent is QueryContinuationSyntax)); 622if (node.Parent.IsKind(SyntaxKind.CollectionInitializerExpression))

BraceCompletion\CurlyBraceCompletionService.cs (2)

150var currentTokenParentParent = currentToken.Parent?.Parent; 206var parentKind = node?.Parent?.Kind();

ChangeSignature\ChangeSignatureFormattingRule.cs (2)

40if (node.Parent != null) 42var baseToken = node.Parent.GetFirstToken();

ChangeSignature\CSharpChangeSignatureService.cs (1)

199for (var current = node; current != null; current = current.Parent)

CodeFixes\Suppression\CSharpSuppressionCodeFixProvider.cs (1)

216return attributeSyntax.Parent is AttributeListSyntax attributeList && attributeList.Attributes.Count == 1;

CodeLens\CSharpCodeLensDisplayInfoService.cs (8)

54node = node.Parent; 59node = node.Parent; 96if (node.Parent.IsKind(SyntaxKind.AccessorList) && 97node.Parent.Parent.IsKind(SyntaxKind.IndexerDeclaration)) 99return GetDisplayName(semanticModel, node.Parent.Parent); 186scopeNode = scopeNode.Parent;

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (2)

40if (localFunction?.Parent is not BlockSyntax parentBlock) 164if (simpleName.Parent is InvocationExpressionSyntax invocation)

CodeRefactorings\InlineMethod\CSharpInlineMethodRefactoringProvider.cs (1)

107return syntaxNode.Parent switch

CodeRefactorings\InlineTemporary\InlineTemporaryCodeRefactoringProvider.cs (28)

56if (variableDeclarator.Parent is not VariableDeclarationSyntax variableDeclaration || 57variableDeclaration.Parent is not LocalDeclarationStatementSyntax localDeclarationStatement) 110if (identifierNode?.Parent is ArgumentSyntax argument) 115else if (identifierNode.Parent.Kind() is 124else if (identifierNode.Parent is AssignmentExpressionSyntax binaryExpression && 225if (identifier.Parent is AnonymousObjectMemberDeclaratorSyntax { NameEquals: null } anonymousMember) 239else if (identifier.Parent is ArgumentSyntax 241Parent: TupleExpressionSyntax tupleExpression, 259else if (identifier.Parent is SpreadElementSyntax spreadElement && 337var variableDeclaration = (VariableDeclarationSyntax)variableDeclarator.Parent; 338var localDeclaration = (LocalDeclarationStatementSyntax)variableDeclaration.Parent; 339var scope = localDeclaration.Parent; 342scope = scope.Parent; 345scope = parentExpressions.LastOrDefault()?.Parent ?? scope; 348scope = scope.Parent; 366var localDeclaration = (LocalDeclarationStatementSyntax)variableDeclaration.Parent; 380var variableDeclaration = (VariableDeclarationSyntax)variableDeclarator.Parent; 386var localDeclaration = (LocalDeclarationStatementSyntax)variableDeclaration.Parent; 411var newLocalDeclaration = (LocalDeclarationStatementSyntax)FindDeclarator(newScope).Parent.Parent; 415if (newLocalDeclaration?.Parent is LabeledStatementSyntax labeledStatement) 422if (newLocalDeclaration?.Parent is GlobalStatementSyntax globalStatement) 450var isVar = ((VariableDeclarationSyntax)variableDeclarator.Parent).Type.IsVar; 505var parent = node.Parent; 507parent = parent.Parent; 511parent = parent.Parent; 516else if (parent?.Parent is AssignmentExpressionSyntax(SyntaxKind.SimpleAssignmentExpression) assignment) 521parent = parent.Parent;

CodeRefactorings\SyncNamespace\CSharpChangeNamespaceService.cs (6)

144RoslynDebug.Assert(nameRef.Parent is object); 145oldNode = nameRef.Parent; 161RoslynDebug.Assert(nameRef.Parent is object); 162oldNode = nameRef.Parent; 175else if (nameRef.Parent is NameMemberCrefSyntax crefName && crefName.Parent is QualifiedCrefSyntax qualifiedCref)

CodeRefactorings\UseExplicitOrImplicitType\AbstractUseTypeCodeRefactoringProvider.cs (6)

95var typeParent = type?.Parent; 99if (type?.Parent is VariableDeclarationSyntax) 100return type.Parent; 106if (type?.Parent is DeclarationExpressionSyntax or VariableDeclarationSyntax) 107return type.Parent; 109if (type?.Parent is ForEachStatementSyntax foreachStatement2 &&

CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (10)

78WhenClauseSyntax { Parent: CasePatternSwitchLabelSyntax switchLabel } whenClause => CombineWhenClauseCondition(switchLabel.Pattern, whenClause.Condition, model), 79WhenClauseSyntax { Parent: SwitchExpressionArmSyntax switchArm } whenClause => CombineWhenClauseCondition(switchArm.Pattern, whenClause.Condition, model), 89WhenClauseSyntax { Parent: CasePatternSwitchLabelSyntax } => true, 90WhenClauseSyntax { Parent: SwitchExpressionArmSyntax } => true, 105if (leftTarget.Parent is IsPatternExpressionSyntax isPatternExpression && 173switch (receiver.GetRequiredParent().Parent) 276ExpressionSyntax constant => originalReceiver.Parent switch 318if (designation is not { Parent: PatternSyntax(not SyntaxKind.ListPattern) containingPattern }) 453var leftIsNullCheck = IsNullCheck(leftTarget.Parent); 454var rightIsNullCheck = IsNullCheck(rightTarget.Parent);

Completion\CompletionProviders\AttributeNamedParameterCompletionProvider.cs (1)

73if (token.Parent!.Parent is not AttributeSyntax attributeSyntax || token.Parent is not AttributeArgumentListSyntax attributeArgumentList)

Completion\CompletionProviders\AwaitCompletionProvider.cs (1)

108if (parent is NameSyntax { Parent: LocalFunctionStatementSyntax localFunction } name &&

Completion\CompletionProviders\CSharpSuggestionModeCompletionProvider.cs (3)

127return token.Parent.Parent is not null and ParenthesizedLambdaExpressionSyntax; 171&& token.Parent.Parent is InvocationExpressionSyntax invocation 216for (var current = patternSyntax; current != null; current = current.Parent as PatternSyntax)

Completion\CompletionProviders\DeclarationName\DeclarationNameInfo.cs (9)

138var argument = token.Parent.Parent as ArgumentSyntax // var is child of ArgumentSyntax, eg. Goo(out var $$ 139?? token.Parent.Parent?.Parent as ArgumentSyntax; // var is child of DeclarationExpression 321v => v.Parent is FieldDeclarationSyntax f ? f.Modifiers : null, 360modifierGetter: v => v.Parent is LocalDeclarationStatementSyntax localDeclaration 399modifierGetter: v => v.Parent is UsingStatementSyntax or ForStatementSyntax 450token.GetAncestor<ParameterSyntax>()?.Parent?.Parent is (kind: SyntaxKind.RecordDeclaration or SyntaxKind.RecordStructDeclaration)) 481parent is TypeArgumentListSyntax { Parent: GenericNameSyntax genericName })

Completion\CompletionProviders\DeclarationName\DeclarationNameRecommender.cs (2)

279if (parameterSyntax is not { Type: { } parameterType, Parent.Parent: BaseMethodDeclarationSyntax baseMethod })

Completion\CompletionProviders\ExplicitInterfaceMemberCompletionProvider.cs (1)

93ancestor = ancestor.Parent;

Completion\CompletionProviders\ExplicitInterfaceMemberCompletionProvider.ItemGetter.cs (1)

90when node.Parent.IsKind(SyntaxKind.IncompleteMember):

Completion\CompletionProviders\ExplicitInterfaceTypeCompletionProvider.cs (2)

75potentialTypeNode = typeArgumentList.Parent; 81if (typeNode.Parent is TypeSyntax parentType && parentType.Span.End < position)

Completion\CompletionProviders\NamedParameterCompletionProvider.cs (3)

82var parameterLists = GetParameterLists(semanticModel, position, argumentList.Parent!, cancellationToken); 234var baseList = baseType.Parent; 235if (baseList?.Parent is not BaseTypeDeclarationSyntax typeDeclaration)

Completion\CompletionProviders\ObjectAndWithInitializerCompletionProvider.cs (3)

74if (token.Parent.Parent is not ExpressionSyntax expression) 119if (token.Parent == null || token.Parent.Parent == null) 142var parent = token.Parent?.Parent;

Completion\CompletionProviders\PropertySubPatternCompletionProvider.cs (7)

58var propertyPatternType = semanticModel.GetTypeInfo((PatternSyntax)propertyPatternClause.Parent!, cancellationToken).ConvertedType; 181return token.Parent is PropertyPatternClauseSyntax { Parent: PatternSyntax } propertyPatternClause 199while (memberAccess.Parent.IsKind(SyntaxKind.SimpleMemberAccessExpression)) 201memberAccess = (MemberAccessExpressionSyntax)memberAccess.Parent; 204if (memberAccess is { Parent.Parent: SubpatternSyntax { Parent: PropertyPatternClauseSyntax found } })

Completion\CompletionProviders\SymbolCompletionProvider.cs (1)

113=> context.TargetToken.Parent?.Parent?.IsKind(SyntaxKind.PrimaryConstructorBaseType) is true;

Completion\CompletionProviders\XmlDocCommentCompletionProvider.cs (11)

149token.Parent.Parent.IsParentKind(SyntaxKind.XmlElement)) 162if (token.Parent.Parent is XmlElementSyntax xmlElement) 168token.Parent.Parent!.Parent is XmlElementSyntax nestedXmlElement) 173if (token.Parent.Parent is DocumentationCommentTriviaSyntax || 174(token.Parent.Parent.IsKind(SyntaxKind.XmlEmptyElement) && token.Parent.Parent.Parent is DocumentationCommentTriviaSyntax)) 236(elementName, attributes) = GetElementNameAndAttributes(token.Parent.Parent!); 250(elementName, attributes) = GetElementNameAndAttributes(attributeSyntax.Parent!); 295token.Parent?.Parent is XmlNameAttributeSyntax xmlName)

Completion\KeywordRecommenders\AssemblyKeywordRecommender.cs (3)

22var parentSyntax = attributeList.Parent; 31case BaseTypeDeclarationSyntax baseType when baseType.Parent is CompilationUnitSyntax: 35case IncompleteMemberSyntax incompleteMember when incompleteMember.Parent is CompilationUnitSyntax:

Completion\KeywordRecommenders\BaseKeywordRecommender.cs (2)

49token.Parent.Parent?.Parent is (kind: SyntaxKind.ClassDeclaration or SyntaxKind.RecordDeclaration))

Completion\KeywordRecommenders\FieldKeywordRecommender.cs (4)

46for (var node = targetToken.Parent; node != null; node = node.Parent) 48if (node is ArrowExpressionClauseSyntax { Parent: PropertyDeclarationSyntax }) 51if (node is AccessorDeclarationSyntax { Parent: AccessorListSyntax { Parent: PropertyDeclarationSyntax } })

Completion\KeywordRecommenders\MethodKeywordRecommender.cs (1)

26Parent: PropertyDeclarationSyntax

Completion\KeywordRecommenders\NamespaceKeywordRecommender.cs (3)

113!token.Parent.Parent.IsKind(SyntaxKind.FileScopedNamespaceDeclaration)) 124token.Parent.Parent is not TypeDeclarationSyntax) 140token.Parent.Parent is not TypeDeclarationSyntax)

Completion\KeywordRecommenders\RefKeywordRecommender.cs (3)

102identifier.Parent is TypeConstraintSyntax typeConstraint && typeConstraint.Type == identifier && 103typeConstraint.Parent is TypeParameterConstraintClauseSyntax constraintClause) 204|| parent?.Parent?.Kind() == SyntaxKind.VariableDeclarator;

Completion\KeywordRecommenders\ReturnKeywordRecommender.cs (1)

37token.Parent.Parent is AccessorDeclarationSyntax;

Completion\KeywordRecommenders\StructKeywordRecommender.cs (2)

59refStructConstraint.Parent is AllowsConstraintClauseSyntax allowsClause && 60allowsClause.Parent is TypeParameterConstraintClauseSyntax)

Completion\KeywordRecommenders\ThisKeywordRecommender.cs (1)

35token.Parent is ConstructorInitializerSyntax { Parent: ConstructorDeclarationSyntax constructor } &&

Completion\KeywordRecommenders\WhenKeywordRecommender.cs (1)

29if (pattern?.Parent is SwitchExpressionArmSyntax)

Completion\KeywordRecommenders\WhereKeywordRecommender.cs (2)

76else if (tokenParent.Parent is LocalFunctionStatementSyntax { TypeParameterList.Parameters.Count: > 0 }) 84if (baseList?.Parent is TypeDeclarationSyntax typeDecl)

ConvertForEachToFor\CSharpConvertForEachToForCodeRefactoringProvider.cs (1)

50return foreachInfo.ForEachStatement.Parent.IsKind(SyntaxKind.Block);

ConvertIfToSwitch\CSharpConvertIfToSwitchCodeRefactoringProvider.cs (1)

39if (syntaxToRemove is (IfStatementSyntax or BlockSyntax) and { Parent: ElseClauseSyntax elseClause } &&

ConvertLinq\ConvertForEachToLinqQuery\CSharpConvertForEachToLinqQueryProvider.cs (2)

292if (forEachInfo.ForEachStatement?.Parent is BlockSyntax block && 293block.Parent == memberDeclarationSyntax)

ConvertLinq\CSharpConvertLinqQueryToForEachProvider.cs (11)

213var identifier = ((QueryBodySyntax)selectClause.Parent).Continuation.Identifier; 223var parent = _source.WalkUpParentheses().Parent; 263currentNode = currentNode.Parent; 279if (memberAccessExpression.Parent is InvocationExpressionSyntax invocationExpression) 419var invocationParent = invocationExpression.WalkUpParentheses().Parent; 461if (invocationParent?.Parent.Kind() is 466((VariableDeclarationSyntax)invocationParent.Parent.Parent).Variables.Count == 1) 468var variableDeclarator = ((VariableDeclaratorSyntax)invocationParent.Parent); 471((VariableDeclarationSyntax)variableDeclarator.Parent).Type, 945node = node.Parent;

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (5)

228if (initializer.Parent is not PropertyDeclarationSyntax and not VariableDeclaratorSyntax { Parent: VariableDeclarationSyntax { Parent: FieldDeclarationSyntax } }) 276if (initializer.Parent is PropertyDeclarationSyntax propertyDeclaration) 285else if (initializer.Parent is VariableDeclaratorSyntax)

ConvertProgram\ConvertProgramTransform_TopLevelStatements.cs (4)

33var typeDeclaration = (TypeDeclarationSyntax?)methodDeclaration.Parent; 44if (typeDeclaration.Parent is not BaseNamespaceDeclarationSyntax namespaceDeclaration) 110var namespaceDeclaration = typeDeclaration.Parent as BaseNamespaceDeclarationSyntax; 264typeDeclaration.Parent is NamespaceDeclarationSyntax namespaceDeclaration)

ConvertToExtension\ConvertToExtensionCodeRefactoringProvider.cs (2)

78if (methodDeclaration.Parent is not ClassDeclarationSyntax classDeclaration) 89if (classDeclaration.Parent is not BaseNamespaceDeclarationSyntax and not CompilationUnitSyntax)

ConvertToRawString\ConvertInterpolatedStringToRawStringCodeRefactoringProvider.cs (1)

277for (var current = node; current != null; current = current.Parent)

Copilot\CSharpImplementNotImplementedExceptionDiagnosticAnalyzer.cs (2)

106operation.Syntax.Parent is not ArrowExpressionClauseSyntax { Parent: PropertyDeclarationSyntax })

Debugging\CSharpProximityExpressionsService.Worker.cs (12)

81if (block != null && block?.Parent is CatchClauseSyntax catchClause && 91? (BlockSyntax)_parentStatement.Parent 98=> _parentStatement.Parent is BlockSyntax parentBlockOpt && parentBlockOpt.Statements.FirstOrDefault() == _parentStatement; 114if (block != null && block.Parent is MemberDeclarationSyntax memberDeclaration) 120&& _parentStatement.Parent is GlobalStatementSyntax { Parent: CompilationUnitSyntax compilationUnit } globalStatement 134block.Parent is AccessorDeclarationSyntax && 135block.Parent.Parent is AccessorListSyntax && 136block.Parent.Parent.Parent is IndexerDeclarationSyntax indexerDeclaration)

Debugging\CSharpProximityExpressionsService_ExpressionTermCollector.cs (1)

189memberAccessExpression.Parent?.Kind() is not SyntaxKind.SimpleMemberAccessExpression and not SyntaxKind.PointerMemberAccessExpression)

Diagnostics\Analyzers\CSharpUnboundIdentifiersDiagnosticAnalyzer.cs (1)

29=> node.Parent is InvocationExpressionSyntax invocation && invocation.IsNameOfInvocation();

DocumentationComments\CSharpDocumentationCommentSnippetService.cs (2)

178for (SyntaxNode? current = exceptionType; current != null; current = current?.Parent) 180if (current is not BlockSyntax { Parent: TryStatementSyntax tryStatement } block ||

EditAndContinue\BreakpointSpans.cs (7)

103node = node.Parent; 556if (switchLabel.Parent is not SwitchSectionSyntax switchSection || switchSection.Statements.Count == 0) 774=> declaration.Parent!.Kind() switch 838var variableDeclaration = (VariableDeclarationSyntax)variableDeclarator.Parent!; 859var variableDeclaration = (VariableDeclarationSyntax)variableDeclarator.Parent!; 943if (expression == null || expression.Parent == null) 948var parent = expression.Parent;

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (91)

126if (current is { Parent.Parent: RecordDeclarationSyntax }) 136Debug.Assert(current.Parent.IsKind(SyntaxKind.VariableDeclaration)); 138switch (current.Parent.Parent!.Kind()) 146current = current.Parent; 151if (current.Parent is (kind: SyntaxKind.PropertyDeclaration or SyntaxKind.IndexerDeclaration)) 160Debug.Assert(current.Parent.IsKind(SyntaxKind.CompilationUnit)); 161declarations = new(current.Parent); 165current = current.Parent; 298node = node.Parent!; 301partnerStatement = partnerStatement.Parent; 375ParameterListSyntax parameters => parameters.Parent!, 391current = current.Parent; 408AccessorDeclarationSyntax { Parent.Parent: IndexerDeclarationSyntax { ParameterList: var list } } => list, 409ArrowExpressionClauseSyntax { Parent: { } memberDecl } => GetDeclarationParameterList(memberDecl), 420(oldBody.Parent.IsKind(SyntaxKind.LocalFunctionStatement) && newBody.Parent.IsKind(SyntaxKind.LocalFunctionStatement))) 441var parent = body.Parent!; 444return parent.IsKind(SyntaxKind.ArrowExpressionClause) && parent.Parent.IsKind(SyntaxKind.LocalFunctionStatement) ? parent.Parent : parent; 642case SyntaxKind.ParameterList when node.Parent is TypeDeclarationSyntax typeDeclaration: 678var parent = statement.Parent; 770if (oldStatement.Parent is UsingStatementSyntax oldUsing) 772return newStatement.Parent is UsingStatementSyntax newUsing && 913=> node is CompilationUnitSyntax ? null : node.Parent!.FirstAncestorOrSelf<BaseTypeDeclarationSyntax>(); 924return declaration.Parent?.Parent is not FieldDeclarationSyntax fieldDeclaration || 932=> declaration.Parent is TypeDeclarationSyntax { ParameterList: var parameterList } and not ExtensionBlockDeclarationSyntax && parameterList == declaration; 1015Contract.ThrowIfNull(declaration.Parent); 1016var recordType = (INamedTypeSymbol?)model.GetDeclaredSymbol(declaration.Parent, cancellationToken); 1018return recordType.InstanceConstructors.Single(ctor => ctor.DeclaringSyntaxReferences is [var syntaxRef] && syntaxRef.GetSyntax(cancellationToken) == declaration.Parent); 1111if (oldNode is ParameterSyntax { Parent.Parent: RecordDeclarationSyntax } || 1112newNode is ParameterSyntax { Parent.Parent: RecordDeclarationSyntax }) 1307Debug.Assert(node.Parent.IsKind(SyntaxKind.AccessorList)); 1309if (HasEdit(editMap, node.Parent, editKind) && !HasEdit(editMap, node.Parent.Parent, editKind)) 1407Contract.ThrowIfNull(node.Parent); 1408node = node.Parent; 1434if (declaration is BaseParameterListSyntax and not { Parent: TypeDeclarationSyntax }) 1436declaration = declaration.Parent; 1442=> node is TypeParameterSyntax ? node.Parent!.Parent! : node!.Parent!; 1671return TryGetDiagnosticSpanImpl(node.Parent!, editKind); 1734return TryGetDiagnosticSpanImpl(node.Parent!, editKind); 1753return TryGetDiagnosticSpanImpl(node.Parent!, editKind); 1877return TryGetDiagnosticSpanImpl(queryBody.Clauses.FirstOrDefault() ?? queryBody.Parent!, editKind); 2050return TryGetDisplayNameImpl(node.Parent!, editKind); 2081if (node.Parent!.Parent!.IsKind(SyntaxKind.PropertyDeclaration)) 2087RoslynDebug.Assert(node.Parent.Parent.IsKind(SyntaxKind.IndexerDeclaration)); 2093if (node.Parent!.Parent!.IsKind(SyntaxKind.PropertyDeclaration)) 2099RoslynDebug.Assert(node.Parent.Parent.IsKind(SyntaxKind.IndexerDeclaration)); 2108return node.Parent!.Kind() switch 2126return node.Parent is TypeDeclarationSyntax ? FeaturesResources.constructor : null; 2272RoslynDebug.Assert(((LocalDeclarationStatementSyntax)node.Parent!.Parent!).AwaitKeyword.IsKind(SyntaxKind.AwaitKeyword)); 2421if (node.IsParentKind(SyntaxKind.CompilationUnit) || node.Parent.IsParentKind(SyntaxKind.CompilationUnit)) 2452if (oldNode.IsParentKind(SyntaxKind.CompilationUnit) || oldNode.Parent.IsParentKind(SyntaxKind.CompilationUnit)) 2475if (newNode.IsParentKind(SyntaxKind.CompilationUnit) || newNode.Parent.IsParentKind(SyntaxKind.CompilationUnit)) 2610RoslynDebug.Assert(current.Parent is object); 2611RoslynDebug.Assert(current.Parent.Kind() == SyntaxKind.TryStatement); 2612current = current.Parent; 2630Debug.Assert(current.Parent != null); 2631current = current.Parent; 2715tryStatement = (TryStatementSyntax)node.Parent!; 2756RoslynDebug.Assert(node.Parent is object); 2757switch (node.Parent.Kind()) 2776node = node.Parent; 2810return awaitExpression.Parent!.Parent!.Parent == containingStatementPart; 2815return awaitExpression.Parent!.Parent!.Parent!.Parent == containingStatementPart; 2883if (oldActiveStatement.Parent!.Parent!.Parent is not SwitchStatementSyntax oldSwitch) 2889var newSwitch = (SwitchStatementSyntax)newActiveStatement.Parent!.Parent!.Parent!; 2979node = node.Parent;

EditAndContinue\DeclarationBody\CSharpLambdaBody.cs (1)

32IsAsync: SyntaxUtilities.IsAsyncDeclaration(node.Parent!),

EditAndContinue\DeclarationBody\FieldWithInitializerDeclarationBody.cs (2)

30=> (BaseFieldDeclarationSyntax)variableDeclarator.Parent!.Parent!;

EditAndContinue\DeclarationBody\SimpleMemberBody.cs (1)

26IsAsync: SyntaxUtilities.IsAsyncDeclaration(Node.Parent!),

EditAndContinue\SyntaxComparer.cs (26)

247if (node != null && node.Parent.IsKind(SyntaxKind.ForStatement) && node is ExpressionSyntax) 469if (node == null || node.Parent.IsKind(SyntaxKind.QueryExpression)) 635if (node?.Parent is (kind: SyntaxKind.PropertyDeclaration or SyntaxKind.IndexerDeclaration)) 679if (node is { Parent: { } parent } && parent.IsParentKind(SyntaxKind.CompilationUnit)) 1047if (leftBlock.Parent == null || 1048rightBlock.Parent == null || 1049leftBlock.Parent.IsKind(SyntaxKind.ConstructorDeclaration) || 1050rightBlock.Parent.IsKind(SyntaxKind.ConstructorDeclaration)) 1056if (GetLabel(leftBlock.Parent) != GetLabel(rightBlock.Parent)) 1062switch (leftBlock.Parent.Kind()) 1079distance = GetDistance(leftBlock.Parent, rightBlock.Parent); 1083var leftCatch = (CatchClauseSyntax)leftBlock.Parent; 1084var rightCatch = (CatchClauseSyntax)rightBlock.Parent; 1088var leftTry = (TryStatementSyntax)leftCatch.Parent!; 1089var rightTry = (TryStatementSyntax)rightCatch.Parent!; 1097distance = GetDistance(leftBlock.Parent, rightBlock.Parent); 1118throw ExceptionUtilities.UnexpectedValue(leftBlock.Parent.Kind()); 1127if (leftNode.Parent != null && 1128rightNode.Parent != null && 1129GetLabel(leftNode.Parent) == GetLabel(rightNode.Parent)) 1131parentDistance = ComputeDistance(leftNode.Parent, rightNode.Parent);

EditAndContinue\SyntaxUtilities.cs (14)

39ArrowExpressionClauseSyntax { Parent: (kind: SyntaxKind.PropertyDeclaration) or (kind: SyntaxKind.IndexerDeclaration) } arrowExpression 40=> new PropertyOrIndexerWithExplicitBodyDeclarationBody((BasePropertyDeclarationSyntax)arrowExpression.Parent!), 55VariableDeclaratorSyntax { Parent.Parent: BaseFieldDeclarationSyntax fieldDeclaration, Initializer: { } } variableDeclarator 59ParameterListSyntax { Parent: TypeDeclarationSyntax typeDeclaration and not ExtensionBlockDeclarationSyntax } 69ParameterSyntax { Parent.Parent: RecordDeclarationSyntax } parameterSyntax when symbol is not IParameterSymbol 107if (syntax is ExpressionSyntax { Parent: ArrowExpressionClauseSyntax }) 113if (syntax is ExpressionSyntax { Parent.Parent: VariableDeclaratorSyntax }) 119if (syntax is ExpressionSyntax { Parent.Parent: PropertyDeclarationSyntax }) 217Contract.ThrowIfNull(declaration.Parent); 218declaration = declaration.Parent;

EncapsulateField\CSharpEncapsulateFieldService.cs (5)

65var declaration = root.GetAnnotatedNodes<SyntaxNode>(tempAnnotation).First().Parent as VariableDeclarationSyntax; 69var fieldSyntax = declaration.Parent as FieldDeclarationSyntax; 91declaration = declarator.Parent as VariableDeclarationSyntax; 115declaration = declarator.Parent as VariableDeclarationSyntax; 154=> field.Parent is TypeDeclarationSyntax;

ExtractMethod\CSharpMethodExtractor.Analyzer.cs (3)

69Parent: VariableDeclarationSyntax 71Parent: LocalDeclarationStatementSyntax 73Parent: BlockSyntax { Statements: [.., var lastBlockStatement] },

ExtractMethod\CSharpMethodExtractor.cs (4)

107return globalStatement.Parent; 113currentNode = currentNode.Parent; 139return globalStatement.Parent; 145return globalStatement.Parent;

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.CallSiteContainerRewriter.cs (4)

54private SyntaxNode ContainerOfStatementsOrFieldToReplace => _firstStatementOrFieldToReplace.Parent; 324var firstMemberIndex = newMembers.FindIndex(s => s == (global ? _firstStatementOrFieldToReplace.Parent : _firstStatementOrFieldToReplace)); 327var lastMemberIndex = newMembers.FindIndex(s => s == (global ? _lastStatementOrFieldToReplace.Parent : _lastStatementOrFieldToReplace)); 416if (node != ContainerOfStatementsOrFieldToReplace.Parent)

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.cs (4)

332Contract.ThrowIfFalse(declStatement.Parent.IsStatementContainerNode()); 334return declStatement.Parent; 902var usingKeyword = originalIdentifierToken.Parent?.Parent?.Parent is LocalDeclarationStatementSyntax { UsingKeyword.FullSpan.IsEmpty: false }

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.ExpressionCodeGenerator.cs (10)

45if (expression.Parent != null && 46expression.Parent.Kind() == SyntaxKind.EqualsValueClause && 47expression.Parent.Parent != null && 48expression.Parent.Parent.Kind() == SyntaxKind.VariableDeclarator) 50var name = ((VariableDeclaratorSyntax)expression.Parent.Parent).Identifier.ValueText; 124scope ??= this.SelectionResult.GetContainingScopeOf<ArrowExpressionClauseSyntax>()?.Parent; 142sourceNode.Parent is MemberAccessExpressionSyntax memberAccessExpression && memberAccessExpression.Name == sourceNode,

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.MultipleStatementsCodeGenerator.cs (2)

40foreach (var statement in GetStatementsFromContainer(firstStatementUnderContainer.Parent)) 75GlobalStatementSyntax globalStatement => ((CompilationUnitSyntax)globalStatement.Parent).Members.OfType<GlobalStatementSyntax>().Select(globalStatement => globalStatement.Statement),

ExtractMethod\CSharpSelectionResult.cs (6)

117return constructorInitializer.Parent; 122return field.Parent; 126return primaryConstructorBaseType.Parent; 129Contract.ThrowIfFalse(last.Parent.IsParentKind(SyntaxKind.CompilationUnit)); 130return last.Parent.Parent;

ExtractMethod\CSharpSelectionResult.ExpressionResult.cs (1)

75if (node.Parent is CastExpressionSyntax castExpression)

ExtractMethod\CSharpSelectionValidator.cs (3)

147for (var current = initialSelectionInfo.CommonRoot; current != null; current = current.Parent) 196firstValidNode = (firstValidNode.Parent is ExpressionStatementSyntax) ? firstValidNode.Parent : firstValidNode;

ExtractMethod\CSharpSelectionValidator.Validator.cs (1)

33return block.Parent is BlockSyntax or

ExtractMethod\Extensions.cs (7)

23for (var current = node; current is object; current = current.Parent) 25if (current.Parent != null && 26current.Parent.IsStatementContainerNode()) 36=> (StatementSyntax)((node.Parent is LabeledStatementSyntax) ? node.Parent : node); 252=> node is InitializerExpressionSyntax && node.Parent is EqualsValueClauseSyntax; 255=> node is ExpressionSyntax && node.Parent is CastExpressionSyntax;

FullyQualify\CSharpFullyQualifyService.cs (1)

59simpleName.Parent is UsingDirectiveSyntax { Alias: null, StaticKeyword.RawKind: 0 } usingDirective)

GenerateMember\GenerateVariable\CSharpGenerateVariableService.cs (14)

96if (identifierName.Parent is MemberAccessExpressionSyntax memberAccessExpression && 101else if (identifierName.Parent.Parent is ConditionalAccessExpressionSyntax conditionalAccessExpression && 102conditionalAccessExpression.WhenNotNull == identifierName.Parent) 106else if (identifierName.Parent is MemberBindingExpressionSyntax memberBindingExpression && 107identifierName.Parent.Parent is AssignmentExpressionSyntax assignmentExpression && 117isConditionalAccessExpression = identifierName.Parent.Parent is ConditionalAccessExpressionSyntax; 191if (expression.Parent is (kind: SyntaxKind.NameColon or SyntaxKind.ExpressionColon) && 192expression.Parent.IsParentKind(SyntaxKind.Subpattern)) 209if (node.IsLeftSideOfAssignExpression() && node.Parent.IsParentKind(SyntaxKind.ExpressionStatement)) 211var assignExpression = (AssignmentExpressionSyntax)node.Parent; 212var expressionStatement = (StatementSyntax)assignExpression.Parent;

GenerateType\CSharpGenerateTypeService.cs (36)

GoToDefinition\CSharpGoToDefinitionSymbolService.cs (3)

102node = node.Parent; 118node = node.Parent; 133node = node.Parent;

Highlighting\KeywordHighlighters\IfStatementHighlighter.cs (1)

34if (ifStatement.Parent.Kind() != SyntaxKind.ElseClause)

ImplementInterface\AbstractChangeImplementationCodeRefactoringProvider.cs (1)

158for (var node = token.Parent; node != null; node = node.Parent)

ImplementInterface\CSharpImplementExplicitlyCodeRefactoringProvider.cs (3)

97? identifierName.Parent 101if (syntaxFacts.IsInvocationExpression(node.Parent)) 102node = node.Parent;

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (2)

47if (selectedParameter.Parent is not ParameterListSyntax { Parent: TypeDeclarationSyntax(kind: SyntaxKind.ClassDeclaration or SyntaxKind.StructDeclaration) typeDeclaration })

InlineHints\CSharpInlineTypeHintsService.cs (4)

51else if (node is SingleVariableDesignationSyntax { Parent: not DeclarationPatternSyntax and not DeclarationExpressionSyntax } variableDesignation) 57return node.Parent is VarPatternSyntax varPattern 80return parameterNode.Parent?.Parent?.Kind() is SyntaxKind.ParenthesizedLambdaExpression

IntroduceParameter\CSharpIntroduceParameterCodeRefactoringProvider.cs (2)

32return variableDecl.Parent?.Parent as LocalDeclarationStatementSyntax;

IntroduceUsingStatement\CSharpIntroduceUsingStatementCodeRefactoringProvider.cs (1)

99if (declarationStatement.Parent is SwitchSectionSyntax ||

IntroduceVariable\CSharpIntroduceVariableService.cs (1)

62for (SyntaxNode? node = expression; node != null; node = node.Parent)

IntroduceVariable\CSharpIntroduceVariableService.Rewriter.cs (1)

65node.Parent is TupleExpressionSyntax)

IntroduceVariable\CSharpIntroduceVariableService_IntroduceLocal.cs (3)

393if (!IsBlockLike(statement.Parent)) 405innermostCommonBlock = statement.Parent; 432if (statement is IfStatementSyntax { Parent: ElseClauseSyntax })

IntroduceVariable\CSharpIntroduceVariableService_IntroduceQueryLocal.cs (1)

87var oldQuery = (QueryBodySyntax)oldClause.Parent;

InvertIf\CSharpInvertIfCodeRefactoringProvider.cs (1)

37=> ifNode?.Parent is (kind: SyntaxKind.Block or SyntaxKind.SwitchSection);

MoveToNamespace\CSharpMoveToNamespaceService.cs (1)

24ParameterListSyntax parameterList => parameterList.Parent as BaseTypeDeclarationSyntax,

QuickInfo\CSharpDiagnosticAnalyzerQuickInfoProvider.cs (3)

59{ Parent: PragmaWarningDirectiveTriviaSyntax } node => node, 102Parent: AttributeArgumentListSyntax 105Parent: AttributeSyntax

QuickInfo\CSharpSemanticQuickInfoProvider.cs (4)

61token.Parent?.Parent.IsKind(SyntaxKind.ElementAccessExpression) == true) 63found = token.Parent.Parent; 109if (node is IdentifierNameSyntax { IsVar: true, Parent: VariableDeclarationSyntax { Variables: [var declarator] } }) 187Parent: VariableDeclarationSyntax { Type.IsVar: true },

QuickInfo\CSharpSyntacticQuickInfoProvider.cs (2)

85spanStart = parent.Parent!.SpanStart; 95&& node.Parent?.Kind() is SyntaxKind.Block or SyntaxKind.SwitchSection or SyntaxKind.GlobalStatement;

RemoveUnusedVariable\CSharpRemoveUnusedVariableCodeFixProvider.cs (5)

40node = node.Parent; 43var parent = node.Parent; 65RemoveNode(editor, node.IsParentKind(SyntaxKind.GlobalStatement) ? node.Parent : node, blockFacts); 77if (node.Parent?.Parent is not LocalDeclarationStatementSyntax localDeclaration)

Rename\CSharpRenameIssuesService.cs (2)

62if (parent?.Parent is VariableDeclarationSyntax varDecl) 66else if (parent?.Parent is FieldDeclarationSyntax fieldDecl)

ReplaceMethodWithProperty\CSharpReplaceMethodWithPropertyService.cs (1)

399if (nameNode.IsAnyMemberAccessExpressionName() && nameNode.Parent == invocationExpression)

ReplacePropertyWithMethods\CSharpReplacePropertyWithMethodsService.cs (1)

298=> identifierName.Parent as NameMemberCrefSyntax;

SignatureHelp\AttributeSignatureHelpProvider.cs (1)

62token.Parent.Parent is AttributeSyntax;

SignatureHelp\ConstructorInitializerSignatureHelpProvider.cs (1)

91var currentConstructor = semanticModel.GetDeclaredSymbol(constructorInitializer.Parent!, cancellationToken);

SignatureHelp\ElementAccessExpressionSignatureHelpProvider.cs (8)

116if (expression.Parent is ConditionalAccessExpressionSyntax conditional) 155if (expression.Parent is ConditionalAccessExpressionSyntax) 283token.Parent.Parent is ElementAccessExpressionSyntax; 295openBracket.Parent.Parent is ElementAccessExpressionSyntax or ElementBindingExpressionSyntax); 336Contract.ThrowIfFalse(openBracket.Parent is ArrayRankSpecifierSyntax && openBracket.Parent.Parent is ArrayTypeSyntax); 367token.Parent.Parent is ElementBindingExpressionSyntax && 368token.Parent.Parent.Parent is ConditionalAccessExpressionSyntax;

SignatureHelp\GenericNameSignatureHelpProvider.cs (3)

66token.Parent.Parent is GenericNameSyntax; 163Contract.ThrowIfFalse(lessThanToken.Parent is TypeArgumentListSyntax && lessThanToken.Parent.Parent is GenericNameSyntax); 164return SignatureHelpUtilities.GetSignatureHelpSpan(((GenericNameSyntax)lessThanToken.Parent.Parent).TypeArgumentList);

SignatureHelp\PrimaryConstructorBaseTypeSignatureHelpProvider.cs (2)

76var baseList = baseTypeSyntax.Parent as BaseListSyntax; 77if (baseList?.Parent is not BaseTypeDeclarationSyntax namedTypeSyntax)

SignatureHelp\SignatureHelpUtilities.cs (5)

108if (parenthesizedExpr.Parent is ArgumentSyntax) 110var parent = parenthesizedExpr.Parent; 111var grandParent = parent.Parent; 112if (grandParent is ArgumentListSyntax && grandParent.Parent is TSyntaxNode) 140token.Parent.Parent is TSyntaxNode;

Snippets\CSharpForEachLoopSnippetProvider.cs (2)

46if (token is { RawKind: (int)SyntaxKind.AwaitKeyword, Parent: ExpressionSyntax { Parent: ExpressionStatementSyntax } } || 47token is { RawKind: (int)SyntaxKind.IdentifierToken, ValueText: "await", Parent: IdentifierNameSyntax { Parent: ExpressionStatementSyntax } })

SplitOrMergeIfStatements\CSharpIfLikeStatementGenerator.cs (8)

33if (expression.Parent is IfStatementSyntax ifStatement && ifStatement.Condition == expression) 45if (node is IfStatementSyntax && node.Parent is ElseClauseSyntax) 47parentIfOrElseIf = (IfStatementSyntax)node.Parent.Parent; 78while (ifStatement.Parent is ElseClauseSyntax elseClause) 80ifStatement = (IfStatementSyntax)elseClause.Parent; 158editor.ReplaceNode(elseIfClause.Parent.Parent, (currentNode, _) =>

src\Analyzers\CSharp\Analyzers\AddAccessibilityModifiers\CSharpAddAccessibilityModifiers.cs (1)

58if (member.Parent is InterfaceDeclarationSyntax)

src\Analyzers\CSharp\Analyzers\AddRequiredParentheses\CSharpAddRequiredExpressionParenthesesDiagnosticAnalyzer.cs (4)

73=> binaryLike.Parent is ConstantPatternSyntax 74? binaryLike.Parent.Parent as ExpressionSyntax 75: binaryLike.Parent as ExpressionSyntax;

src\Analyzers\CSharp\Analyzers\AddRequiredParentheses\CSharpAddRequiredPatternParenthesesDiagnosticAnalyzer.cs (1)

38=> binaryLike.Parent as PatternSyntax;

src\Analyzers\CSharp\Analyzers\ConvertProgram\ConvertProgramAnalysis_TopLevelStatements.cs (1)

61methodDeclaration.Parent is not TypeDeclarationSyntax containingTypeDeclaration ||

src\Analyzers\CSharp\Analyzers\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs (2)

65if (declaration.Parent == node.Parent && declarator.Initializer is null)

src\Analyzers\CSharp\Analyzers\ConvertTypeofToNameof\CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs (1)

34return node is TypeOfExpressionSyntax { Parent: MemberAccessExpressionSyntax } typeofExpression &&

src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (8)

96if (argumentNode.Parent is not ArgumentListSyntax argumentList) 101var invocationOrCreation = argumentList.Parent; 144var localDeclaration = localDeclarator.Parent as VariableDeclarationSyntax; 145if (localDeclaration?.Parent is not LocalDeclarationStatementSyntax localStatement) 277for (var current = argumentExpression; current != null; current = current.Parent) 280if (current.Parent is LambdaExpressionSyntax lambda && current == lambda.Body) 284if (current.Parent is SwitchExpressionArmSyntax switchArm && current == switchArm.Expression) 319? current.Parent

src\Analyzers\CSharp\Analyzers\NamingStyle\CSharpNamingStyleDiagnosticAnalyzer.cs (2)

33Parent: ParameterListSyntax 35Parent: RecordDeclarationSyntax

src\Analyzers\CSharp\Analyzers\NewLines\ArrowExpressionClausePlacement\ArrowExpressionClausePlacementDiagnosticAnalyzer.cs (1)

68if (arrowExpressionClause.Parent is AccessorDeclarationSyntax)

src\Analyzers\CSharp\Analyzers\NewLines\EmbeddedStatementPlacement\EmbeddedStatementPlacementDiagnosticAnalyzer.cs (2)

87var parent = statement.Parent; 110var blockParent = parent.Parent;

src\Analyzers\CSharp\Analyzers\QualifyMemberAccess\CSharpQualifyMemberAccessDiagnosticAnalyzer.cs (2)

44if (node.Parent is AssignmentExpressionSyntax { Parent: InitializerExpressionSyntax(SyntaxKind.ObjectInitializerExpression), Left: var left } &&

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryDiscardDesignation\CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs (3)

55if (discard.Parent is DeclarationPatternSyntax declarationPattern) 59if (declarationPattern.Parent is not IsPatternExpressionSyntax) 81else if (discard.Parent is RecursivePatternSyntax recursivePattern)

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (2)

262node1 = node1.Parent; 263node2 = node2.Parent;

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\NullableImpactingSpanWalker.cs (4)

66if (node?.Parent is QualifiedNameSyntax qualifiedName 85if (node?.Parent is BaseNamespaceDeclarationSyntax) 91if (node.IsParentKind(SyntaxKind.NameEquals) && node.Parent.IsParentKind(SyntaxKind.UsingDirective)) 109while (node.Parent is QualifiedNameSyntax qualifiedName

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryParentheses\CSharpRemoveUnnecessaryExpressionParenthesesDiagnosticAnalyzer.cs (2)

55switch (parenthesizedExpression.Parent) 80case ConstantPatternSyntax constantPattern when constantPattern.Parent is IsPatternExpressionSyntax isPatternExpression:

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryParentheses\CSharpRemoveUnnecessaryPatternParenthesesDiagnosticAnalyzer.cs (2)

51if (parenthesizedPattern.Parent is not PatternSyntax) 60if (parenthesizedPattern.Parent is not BinaryPatternSyntax parentPattern)

src\Analyzers\CSharp\Analyzers\RemoveUnreachableCode\RemoveUnreachableCodeHelpers.cs (2)

16switch (firstUnreachableStatement.Parent) 27if (globalStatement.Parent is not CompilationUnitSyntax compilationUnit)

src\Analyzers\CSharp\Analyzers\RemoveUnusedMembers\CSharpRemoveUnusedMembersDiagnosticAnalyzer.cs (2)

41=> variableDeclarator.Parent is VariableDeclarationSyntax 43Parent: FieldDeclarationSyntax { Declaration.Variables.Count: 0 } or

src\Analyzers\CSharp\Analyzers\RemoveUnusedParametersAndValues\CSharpRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs (2)

69var statementAncestor = unusedSymbolWriteOperation.Syntax.FirstAncestorOrSelf<StatementSyntax>()?.Parent; 103if (unusedDefinition.Syntax.Parent is ForEachStatementSyntax forEachStatement &&

src\Analyzers\CSharp\Analyzers\SimplifyInterpolation\CSharpSimplifyInterpolationHelpers.cs (1)

23ConditionalExpressionSyntax { Parent: ParenthesizedExpressionSyntax parent } => parent,

src\Analyzers\CSharp\Analyzers\SimplifyPropertyAccessor\CSharpSimplifyPropertyAccessorDiagnosticAnalyzer.cs (2)

85if (accessorDeclaration is { Parent: AccessorListSyntax { Parent: BasePropertyDeclarationSyntax containingPropertyDeclaration } containingAccessorList } &&

src\Analyzers\CSharp\Analyzers\SimplifyPropertyPattern\SimplifyPropertyPatternHelpers.cs (1)

25Parent: PropertyPatternClauseSyntax,

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForArrayDiagnosticAnalyzer.cs (4)

150var isConcreteOrImplicitArrayCreation = initializer.Parent is ArrayCreationExpressionSyntax or ImplicitArrayCreationExpressionSyntax; 153if (!isConcreteOrImplicitArrayCreation && initializer.Parent is not EqualsValueClauseSyntax) 175var matches = initializer.Parent switch 189Debug.Assert(initializer.Parent is EqualsValueClauseSyntax);

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderDiagnosticAnalyzer.cs (6)

136if (invocationExpression.Parent is not EqualsValueClauseSyntax { Parent: VariableDeclaratorSyntax { Parent: VariableDeclarationSyntax { Parent: LocalDeclarationStatementSyntax localDeclarationStatement } } declarator }) 216identifierName.Parent is MemberAccessExpressionSyntax(SyntaxKind.SimpleMemberAccessExpression) memberAccess && 218memberAccess.Parent is InvocationExpressionSyntax { ArgumentList.Arguments.Count: 0 } invocationExpression &&

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForEmptyDiagnosticAnalyzer.cs (1)

41: memberAccess.Parent is InvocationExpressionSyntax invocation && IsCollectionEmptyAccess(semanticModel, invocation, cancellationToken)

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs (3)

79if (memberAccess.Parent is not InvocationExpressionSyntax invocation) 87if (invocation.Parent is MemberAccessExpressionSyntax { Parent: InvocationExpressionSyntax parentInvocation } parentMemberAccess &&

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (17)

104if (topMostExpression.Parent is CastExpressionSyntax castExpression && castExpression.Type is IdentifierNameSyntax) 439if (locallyScopedExpression.Parent is ExpressionStatementSyntax) 444if (locallyScopedExpression.Parent is ReturnStatementSyntax or ArrowExpressionClauseSyntax) 447if (locallyScopedExpression.Parent is ArgumentSyntax argument) 457if (locallyScopedExpression.Parent is MemberAccessExpressionSyntax memberAccess && 460if (memberAccess.Parent is InvocationExpressionSyntax invocationExpression) 482if (locallyScopedExpression.Parent is ElementAccessExpressionSyntax elementAccess) 496if (locallyScopedExpression.Parent is EqualsValueClauseSyntax { Parent: VariableDeclaratorSyntax declarator }) 505if (locallyScopedExpression.Parent is AssignmentExpressionSyntax assignment && 585if (argument.Parent is not BaseArgumentListSyntax { Parent: ExpressionSyntax parentInvocation } argumentList) 659Contract.ThrowIfFalse(originalInitializer.Parent 783if (expression.WalkUpParentheses().Parent is not EqualsValueClauseSyntax 785Parent: VariableDeclaratorSyntax 788Parent.Parent: LocalDeclarationStatementSyntax localDeclarationStatement

src\Analyzers\CSharp\Analyzers\UseConditionalExpression\CSharpUseConditionalExpressionForReturnDiagnosticAnalyzer.cs (1)

39if (block.Syntax.Parent is UnsafeStatementSyntax or CheckedStatementSyntax)

src\Analyzers\CSharp\Analyzers\UseDeconstruction\CSharpUseDeconstructionDiagnosticAnalyzer.cs (3)

103if (variableDeclaration is not { Parent: LocalDeclarationStatementSyntax localDeclaration, Variables: [{ Initializer.Value: { } initializerValue } declarator] }) 110var searchScope = localDeclaration.Parent is GlobalStatementSyntax globalStatement 259if (identifierName.Parent is not MemberAccessExpressionSyntax memberAccess)

src\Analyzers\CSharp\Analyzers\UseImplicitObjectCreation\CSharpUseImplicitObjectCreationDiagnosticAnalyzer.cs (16)

85if (objectCreation.Parent is EqualsValueClauseSyntax 87Parent: VariableDeclaratorSyntax { Parent: VariableDeclarationSyntax { Type.IsVar: false } variableDeclaration } 100else if (objectCreation.Parent.IsKind(SyntaxKind.ArrowExpressionClause)) 102typeNode = objectCreation.Parent.Parent switch 109AccessorDeclarationSyntax(SyntaxKind.GetAccessorDeclaration) { Parent: AccessorListSyntax { Parent: BasePropertyDeclarationSyntax baseProperty } } => baseProperty.Type, 113else if (objectCreation.Parent is InitializerExpressionSyntax { Parent: ObjectCreationExpressionSyntax { Type: var collectionType } }) 122else if (objectCreation.Parent is InitializerExpressionSyntax(kind: SyntaxKind.ArrayInitializerExpression) 124Parent: EqualsValueClauseSyntax { Parent: VariableDeclaratorSyntax { Parent: VariableDeclarationSyntax arrayVariableDeclaration } } 129else if (objectCreation.Parent is InitializerExpressionSyntax { Parent: ArrayCreationExpressionSyntax { Type: var arrayCreationType } })

src\Analyzers\CSharp\Analyzers\UseInferredMemberName\CSharpUseInferredMemberNameDiagnosticAnalyzer.cs (2)

34if (nameColon.Parent is not ArgumentSyntax argument) 63if (nameEquals.Parent is not AnonymousObjectMemberDeclaratorSyntax anonCtor)

src\Analyzers\CSharp\Analyzers\UseLocalFunction\CSharpUseLocalFunctionDiagnosticAnalyzer.cs (12)

93if (localDeclaration.Parent is not BlockSyntax block) 216Parent: EqualsValueClauseSyntax 218Parent: VariableDeclaratorSyntax 220Parent: VariableDeclarationSyntax 222Parent: LocalDeclarationStatementSyntax declaration, 267if (nodeToCheck.Parent is BinaryExpressionSyntax) 274if (nodeToCheck.Parent is InvocationExpressionSyntax invocationExpression) 278else if (nodeToCheck.Parent is MemberAccessExpressionSyntax memberAccessExpression) 280if (memberAccessExpression.Parent is InvocationExpressionSyntax explicitInvocationExpression && 353if (anonymousFunction?.Parent is AssignmentExpressionSyntax(SyntaxKind.SimpleAssignmentExpression) assignment && 354assignment.Parent is ExpressionStatementSyntax expressionStatement && 355expressionStatement.Parent is BlockSyntax block)

src\Analyzers\CSharp\Analyzers\UseNameofInNullableAttribute\CSharpUseNameofInNullableAttributeDiagnosticAnalyzer.cs (4)

113var attributeList = attribute.Parent as AttributeListSyntax; 114var container = attributeList?.Parent; 118var parameterList = container.Parent as BaseParameterListSyntax; 119container = parameterList?.Parent;

src\Analyzers\CSharp\Analyzers\UsePatternCombinators\CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs (1)

125return node.WalkUpParentheses().Parent switch

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (1)

328if (statement.Parent is BlockSyntax block)

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.cs (4)

104if (declarator is not { Parent.Parent: LocalDeclarationStatementSyntax localStatement }) 112var enclosingBlock = localStatement.Parent; 241if (identifierName.Parent is AssignmentExpressionSyntax assignmentExpression &&

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpIsAndCastCheckDiagnosticAnalyzer.cs (3)

95var ifStatementScope = ifStatement.Parent.IsKind(SyntaxKind.Block) 96? ifStatement.Parent 173if (!isExpression.Parent.IsKind(SyntaxKind.IfStatement, out ifStatement))

src\Analyzers\CSharp\Analyzers\UsePatternMatching\UsePatternMatchingHelpers.cs (5)

29if (asExpression.Parent is not ParenthesizedExpressionSyntax 32Parent: ConditionalAccessExpressionSyntax parentConditionalAccess 54if (conditionalAccessExpression.Parent is BinaryExpressionSyntax(SyntaxKind.EqualsExpression) parentBinaryExpression1 && 63else if (conditionalAccessExpression.Parent is 81else if (conditionalAccessExpression.Parent is IsPatternExpressionSyntax parentIsPatternExpression)

src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (3)

125else if (nodeToRemove is VariableDeclaratorSyntax { Parent: VariableDeclarationSyntax { Parent: FieldDeclarationSyntax field } }) 315if (primaryConstructorDeclaration.Parent is not TypeDeclarationSyntax)

src\Analyzers\CSharp\Analyzers\UseSystemThreadingLock\CSharpUseSystemThreadingLockDiagnosticAnalyzer.cs (2)

116if (variableDeclarator.Parent is not VariableDeclarationSyntax { Parent: FieldDeclarationSyntax, Variables.Count: 1 })

src\Analyzers\CSharp\Analyzers\UseUtf8StringLiteral\UseUtf8StringLiteralDiagnosticAnalyzer.cs (2)

104else if (elements is [{ Syntax.Parent: ArgumentSyntax }, ..]) 109else if (elements is [{ Syntax.Parent: (kind: SyntaxKind.CollectionInitializerExpression) }, ..])

src\Analyzers\CSharp\CodeFixes\AddExplicitCast\ArgumentFixer.cs (1)

31var newInvocation = newArgumentList.Parent!;

src\Analyzers\CSharp\CodeFixes\AddExplicitCast\AttributeArgumentFixer.cs (1)

31var newAttribute = (AttributeSyntax)newArgumentList.Parent!;

src\Analyzers\CSharp\CodeFixes\AddExplicitCast\CSharpAddExplicitCastCodeFixProvider.cs (4)

71&& targetArgument.Parent is ArgumentListSyntax argumentList 72&& argumentList.Parent is SyntaxNode invocationNode) 79&& targetAttributeArgument.Parent is AttributeArgumentListSyntax attributeArgumentList 80&& attributeArgumentList.Parent is AttributeSyntax attributeNode)

src\Analyzers\CSharp\CodeFixes\AddInheritdoc\AddInheritdocCodeFixProvider.cs (4)

49if (node.IsKind(SyntaxKind.VariableDeclarator) && node is not { Parent.Parent: EventFieldDeclarationSyntax }) 76if (node is VariableDeclaratorSyntax { Parent.Parent: EventFieldDeclarationSyntax eventField })

src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AbstractAssignOutParametersCodeFixProvider.cs (5)

67return location.Parent is BlockSyntax 68|| location.Parent is SwitchSectionSyntax 69|| location.Parent.IsEmbeddedStatementOwner(); 74return location.Parent is ArrowExpressionClauseSyntax or LambdaExpressionSyntax; 82for (var current = node; current != null; current = current.Parent)

src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AssignOutParametersAtStartCodeFixProvider.cs (2)

40statement.Parent is BlockSyntax block && 42block.Parent == container)

src\Analyzers\CSharp\CodeFixes\ConvertNamespace\ConvertNamespaceTransform.cs (1)

138if (stringLiteral.GetRequiredParent() is not InterpolatedStringTextSyntax { Parent: InterpolatedStringExpressionSyntax { StringStartToken: (kind: SyntaxKind.InterpolatedMultiLineRawStringStartToken) } interpolatedString })

src\Analyzers\CSharp\CodeFixes\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionCodeFixProvider.cs (2)

97if (declaratorToRemoveNode.Parent is VariableDeclarationSyntax { Parent: LocalDeclarationStatementSyntax declStatement, Variables.Count: 1 })

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (4)

184(expression.Parent as AssignmentExpressionSyntax)?.Parent as ExpressionStatementSyntax) 502.Select(referenceLocations => referenceLocations.Location.FindNode(cancellationToken).Parent) 521expression => objectCreationExpression.Initializer!.Expressions.IndexOf(expression.Parent));

src\Analyzers\CSharp\CodeFixes\FixIncorrectConstraint\CSharpFixIncorrectConstraintCodeFixProvider.cs (1)

41if (constraint.Parent is not TypeParameterConstraintClauseSyntax)

src\Analyzers\CSharp\CodeFixes\GenerateConstructor\CSharpGenerateConstructorService.cs (2)

91if (fullName.Parent is ObjectCreationExpressionSyntax objectCreationExpression) 123if (fullName.Parent is AttributeSyntax attribute)

src\Analyzers\CSharp\CodeFixes\GenerateDefaultConstructors\CSharpGenerateDefaultConstructorsService.cs (3)

44if (node is { Parent: BaseTypeSyntax { Parent: BaseListSyntax { Types: [var firstType, ..] } baseList } }) 46if (baseList.Parent is TypeDeclarationSyntax(SyntaxKind.ClassDeclaration or SyntaxKind.RecordDeclaration) parentTypeDecl &&

src\Analyzers\CSharp\CodeFixes\GenerateEnumMember\CSharpGenerateEnumMemberService.cs (1)

34simpleNameOrMemberAccessExpression = identifierName.Parent is MemberAccessExpressionSyntax memberAccess && memberAccess.Name == identifierName

src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateConversionService.cs (1)

30node.Parent is AssignmentExpressionSyntax or EqualsValueClauseSyntax &&

src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateMethodService.cs (4)

90simpleName is { Parent: MemberBindingExpressionSyntax { Parent: InvocationExpressionSyntax { Parent: ConditionalAccessExpressionSyntax conditionalAccessExpression1 } invocation1 } memberBinding } && 112isInConditionalAccessExpression = invocationExpressionOpt.Parent is ConditionalAccessExpressionSyntax { WhenNotNull: var whenNotNull } &&

src\Analyzers\CSharp\CodeFixes\ImplementInterface\CSharpImplementInterfaceService.cs (4)

37=> type?.Parent is BaseTypeSyntax { Parent: BaseListSyntax } baseTypeParent && baseTypeParent.Type == type; 56if (node is TypeSyntax interfaceNode && interfaceNode.Parent is BaseTypeSyntax baseType && 57baseType.Parent is BaseListSyntax baseList &&

src\Analyzers\CSharp\CodeFixes\InlineDeclaration\CSharpInlineDeclarationCodeFixProvider.cs (5)

56declarationsToRemove.Add((LocalDeclarationStatementSyntax)diagnostic.AdditionalLocations[0].FindNode(cancellationToken).Parent.Parent); 109var declaration = (VariableDeclarationSyntax)declarator.Parent; 118var localDeclarationStatement = (LocalDeclarationStatementSyntax)declaration.Parent; 176editor.RemoveNode(localDeclarationStatement.Parent is GlobalStatementSyntax globalStatement

src\Analyzers\CSharp\CodeFixes\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessCodeFixProvider.cs (1)

99if (ifStatement.Parent.IsKind(SyntaxKind.ElseClause) &&

src\Analyzers\CSharp\CodeFixes\Iterator\CSharpChangeToIEnumerableCodeFixProvider.cs (4)

88if (node.Parent?.Parent is PropertyDeclarationSyntax oldAccessor) 93if (node.Parent?.Parent is IndexerDeclarationSyntax oldIndexer)

src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (1)

72if (identifierNode.Parent is InvocationExpressionSyntax invocation)

src\Analyzers\CSharp\CodeFixes\MakeMemberRequired\CSharpMakeMemberRequiredCodeFixProvider.cs (4)

49if (node is not (PropertyDeclarationSyntax or VariableDeclaratorSyntax { Parent.Parent: FieldDeclarationSyntax })) 124if (memberDeclarator is VariableDeclaratorSyntax { Parent.Parent: FieldDeclarationSyntax fieldDeclaration })

src\Analyzers\CSharp\CodeFixes\MakeMemberStatic\CSharpMakeMemberStaticCodeFixProvider.cs (4)

31if (node.IsKind(SyntaxKind.VariableDeclarator) && node.Parent is VariableDeclarationSyntax { Parent: FieldDeclarationSyntax or EventFieldDeclarationSyntax }) 33memberDeclaration = node.Parent.Parent;

src\Analyzers\CSharp\CodeFixes\MakeStatementAsynchronous\CSharpMakeStatementAsynchronousCodeFixProvider.cs (2)

98if (node.Parent is (kind: 103return node.Parent;

src\Analyzers\CSharp\CodeFixes\MakeStructMemberReadOnly\CSharpMakeStructMemberReadOnlyCodeFixProvider.cs (2)

53else if (declaration is AccessorDeclarationSyntax { Parent: AccessorListSyntax { Parent: BasePropertyDeclarationSyntax property } accessorList } accessor)

src\Analyzers\CSharp\CodeFixes\Nullable\CSharpDeclareAsNullableCodeFixProvider.cs (20)

59if (node.Parent is ArgumentSyntax) 63if (node.Parent is AssignmentExpressionSyntax) 116if (node.Parent is (kind: SyntaxKind.ReturnStatement or SyntaxKind.YieldReturnStatement)) 161if (node.Parent?.Parent?.Parent is VariableDeclarationSyntax variableDeclaration) 170if (node.Parent is AssignmentExpressionSyntax assignment) 176if (syntax is VariableDeclaratorSyntax { Parent: VariableDeclarationSyntax { Variables.Count: 1 } declaration }) 187if (syntax is VariableDeclaratorSyntax { Parent: VariableDeclarationSyntax { Variables.Count: 1 } declaration }) 212if (node.Parent is ArgumentSyntax argument && argument.Parent?.Parent is InvocationExpressionSyntax invocation) 239if (node.Parent?.Parent is PropertyDeclarationSyntax propertyDeclaration) 249if (node is VariableDeclaratorSyntax { Parent: VariableDeclarationSyntax { Parent: FieldDeclarationSyntax, Variables.Count: 1 } declarationSyntax }) 253if (node.Parent?.Parent is ParameterSyntax optionalParameter) 261node.Parent?.Parent is MethodDeclarationSyntax arrowMethod)

src\Analyzers\CSharp\CodeFixes\RemoveUnnecessaryDiscardDesignation\CSharpRemoveUnnecessaryDiscardDesignationCodeFixProvider.cs (2)

43switch (discard.Parent) 46if (declarationPattern.Parent is IsPatternExpressionSyntax isPattern)

src\Analyzers\CSharp\CodeFixes\RemoveUnreachableCode\CSharpRemoveUnreachableCodeCodeFixProvider.cs (1)

82if (statement.Parent?.Kind()

src\Analyzers\CSharp\CodeFixes\RemoveUnusedLocalFunction\CSharpRemoveUnusedLocalFunctionCodeFixProvider.cs (1)

57editor.RemoveNode(localFunction.Parent is GlobalStatementSyntax globalStatement ? globalStatement : localFunction);

src\Analyzers\CSharp\CodeFixes\RemoveUnusedParametersAndValues\CSharpRemoveUnusedValuesCodeFixProvider.cs (4)

42=> declarator.Parent?.Parent as LocalDeclarationStatementSyntax; 56variableDeclarator.Parent is VariableDeclarationSyntax parent) 212if (originalCompoundAssignment.Parent.IsKind(SyntaxKind.ExpressionStatement))

src\Analyzers\CSharp\CodeFixes\SimplifyPropertyAccessor\CSharpSimplifyPropertyAccessorCodeFixProvider.cs (2)

52if (accessor.Parent?.Parent is PropertyDeclarationSyntax containingProperty &&

src\Analyzers\CSharp\CodeFixes\UseAutoProperty\UseAutoPropertyRewriter.cs (2)

45if (node.Parent is AssignmentExpressionSyntax 47Parent: InitializerExpressionSyntax { RawKind: (int)SyntaxKind.ObjectInitializerExpression }

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpCollectionExpressionRewriter.cs (3)

543Contract.ThrowIfNull(expression.Parent); 587for (var current = node; current != null; current = current.Parent) 810Contract.ThrowIfNull(expression.Parent);

src\Analyzers\CSharp\CodeFixes\UseCollectionInitializer\CSharpUseCollectionInitializerCodeFixProvider_CollectionInitializer.cs (1)

98Contract.ThrowIfNull(expression.Parent);

src\Analyzers\CSharp\CodeFixes\UseCompoundAssignment\CSharpUseCompoundAssignmentCodeFixProvider.cs (1)

52if (currentAssignment.Parent is ForStatementSyntax forStatement &&

src\Analyzers\CSharp\CodeFixes\UseConditionalExpression\CSharpUseConditionalExpressionForAssignmentCodeFixProvider.cs (1)

47if (ifStatement.Parent is ElseClauseSyntax &&

src\Analyzers\CSharp\CodeFixes\UseConditionalExpression\CSharpUseConditionalExpressionForReturnCodeFixProvider.cs (1)

34if (ifStatement.Parent is ElseClauseSyntax &&

src\Analyzers\CSharp\CodeFixes\UseExpressionBody\UseExpressionBodyCodeFixProvider.cs (1)

90if (declaration.Parent is AccessorListSyntax accessorList)

src\Analyzers\CSharp\CodeFixes\UseImplicitOrExplicitType\UseExplicitTypeCodeFixProvider.cs (4)

59var declarationContext = node.Parent; 63declarationContext = declarationContext.Parent; 93RoslynDebug.AssertNotNull(typeSyntax.Parent); 95var tupleTypeSymbol = GetConvertedType(semanticModel, typeSyntax.Parent, cancellationToken);

src\Analyzers\CSharp\CodeFixes\UseIndexOrRangeOperator\CSharpUseRangeOperatorCodeFixProvider.cs (1)

228while (expr?.Parent is CheckedExpressionSyntax parent)

src\Analyzers\CSharp\CodeFixes\UseNullPropagation\CSharpUseNullPropagationCodeFixProvider.cs (1)

47var elseClauseSyntax = (ElseClauseSyntax)ifStatement.Parent!;

src\Analyzers\CSharp\CodeFixes\UsePatternMatching\CSharpAsAndNullCheckCodeFixProvider.cs (4)

75if (statement.Parent is BlockSyntax or SwitchSectionSyntax) 77statementParentScopes.Add(statement.Parent); 110if (declarator.Parent is VariableDeclarationSyntax declaration && 111declaration.Parent is LocalDeclarationStatementSyntax localDeclaration &&

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (2)

285if (nameSyntax.Parent is QualifiedNameSyntax qualifiedNameSyntax) 294else if (nameSyntax.Parent is MemberAccessExpressionSyntax memberAccessExpression)

src\Analyzers\CSharp\CodeFixes\UseSimpleUsingStatement\UseSimpleUsingStatementCodeFixProvider.cs (2)

49var blockLikes = topmostUsingStatements.Select(u => u.Parent is GlobalStatementSyntax ? u.Parent.GetRequiredParent() : u.GetRequiredParent()).ToSet();

src\Analyzers\CSharp\CodeFixes\UseSystemThreadingLock\CSharpUseSystemThreadingLockCodeFixProvider.cs (4)

90if (variableDeclarator.Parent is not VariableDeclarationSyntax { Parent: FieldDeclarationSyntax } variableDeclaration) 141if (expression.Parent is MemberAccessExpressionSyntax memberAccess && 147if (expression.Parent is not AssignmentExpressionSyntax assignment ||

src\Analyzers\CSharp\CodeFixes\UseThrowExpression\UseThrowExpressionCodeFixProvider.cs (1)

63if (throwStatementExpression.Parent is ThrowStatementSyntax throwStatement &&

src\Compilers\CSharp\CSharpAnalyzerDriver\CSharpDeclarationComputer.cs (1)

225if (node.Parent is BasePropertyDeclarationSyntax parentProperty)

src\Compilers\CSharp\Portable\Syntax\LambdaUtilities.cs (21)

42return !node.Parent.IsKind(SyntaxKind.QueryExpression); 55Debug.Assert(lambdaBody.Parent is object); 56var lambda = lambdaBody.Parent; 62lambda = lambda.Parent; 75Debug.Assert(oldBody.Parent is object); 105var oldJoin = (JoinClauseSyntax)oldBody.Parent; 111var oldGroup = (GroupClauseSyntax)oldBody.Parent; 143var parent = node?.Parent; 163return arrowExpressionClause.Expression == node && arrowExpressionClause.Parent is LocalFunctionStatementSyntax; 167return fromClause.Expression == node && fromClause.Parent is QueryBodySyntax; 230Debug.Assert(selectOrGroupClause.Parent!.Parent is object); 231var containingQueryOrContinuation = selectOrGroupClause.Parent.Parent; 300if (node.Parent.IsKind(SyntaxKind.QueryExpression)) 442if (node.Parent != null) 444switch (node.Parent.Kind()) 450SeparatedSyntaxList<ExpressionSyntax> incrementors = ((ForStatementSyntax)node.Parent).Incrementors; 468if (node is ExpressionSyntax && node.Parent != null && node.Parent.Parent == null)

src\Compilers\CSharp\Portable\Syntax\SyntaxBindingUtilities.cs (4)

17or VariableDeclaratorSyntax { Parent.Parent: UsingStatementSyntax { AwaitKeyword.RawKind: not 0 } or LocalDeclarationStatementSyntax { AwaitKeyword.RawKind: not 0 } } 21=> node is VariableDeclaratorSyntax { Parent.Parent: UsingStatementSyntax { } or LocalDeclarationStatementSyntax { UsingKeyword.RawKind: not 0 } }

Structure\Providers\BlockSyntaxStructureProvider.cs (2)

40if (parent is IfStatementSyntax { Parent: not ElseClauseSyntax } ifStatement) 180if (node.Parent.IsKind(SyntaxKind.IfStatement))

Structure\Providers\CollectionExpressionStructureProvider.cs (2)

22if (node.Parent?.Parent is CollectionExpressionSyntax)

Structure\Providers\InitializerExpressionStructureProvider.cs (2)

24if (node.Parent is InitializerExpressionSyntax) 65hintSpan: node.Parent.Span,

UseExpressionBody\UseExpressionBodyCodeRefactoringProvider.cs (2)

152for (var current = node; current != null; current = current.Parent) 178? declaration.Parent

UseNamedArguments\CSharpUseNamedArgumentsCodeRefactoringProvider.cs (2)

30=> argument.Parent?.Parent;

UsePatternMatching\CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs (1)

254for (SyntaxNode? current = isExpression; current != null; current = current.Parent)

Wrapping\SeparatedSyntaxList\CSharpArgumentWrapper.cs (1)

106for (var current = token.Parent; current != listSyntax; current = current?.Parent)