Parent

AddImport\CSharpAddImportFeatureService.cs (10)

63else if (node.Parent.IsKind(SyntaxKind.CollectionInitializerExpression)) 82var memberAccessName = (node.Parent as MemberAccessExpressionSyntax)?.Name; 83var conditionalAccessName = (((node.Parent as ConditionalAccessExpressionSyntax)?.WhenNotNull as InvocationExpressionSyntax)?.Expression as MemberBindingExpressionSyntax)?.Name; 114if (nameNode?.Parent?.Kind() is not SyntaxKind.SimpleMemberAccessExpression and not SyntaxKind.MemberBindingExpression) 117var memberAccess = nameNode.Parent as MemberAccessExpressionSyntax; 118var memberBinding = nameNode.Parent as MemberBindingExpressionSyntax; 119if (memberAccess?.Parent?.Kind() is SyntaxKind.SimpleMemberAccessExpression or SyntaxKind.ElementAccessExpression || 120memberBinding?.Parent?.Kind() is SyntaxKind.SimpleMemberAccessExpression or SyntaxKind.ElementAccessExpression) 158node.AncestorsAndSelf().Any(n => n is QueryExpressionSyntax && !(n.Parent is QueryContinuationSyntax)); 632if (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 (1)

186if (node.Parent is InvocationExpressionSyntax invocation)

CodeRefactorings\InlineMethod\CSharpInlineMethodRefactoringProvider.cs (1)

107return syntaxNode.Parent switch

CodeRefactorings\InlineTemporary\InlineTemporaryCodeRefactoringProvider.cs (21)

57variableDeclaration.Parent is not LocalDeclarationStatementSyntax localDeclarationStatement) 241Parent: TupleExpressionSyntax tupleExpression, 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\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (9)

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 && 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\AwaitCompletionProvider.cs (1)

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

Completion\CompletionProviders\CSharpSuggestionModeCompletionProvider.cs (2)

127return token.Parent.Parent is not null and ParenthesizedLambdaExpressionSyntax; 171&& token.Parent.Parent is InvocationExpressionSyntax invocation

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

141var argument = token.Parent.Parent as ArgumentSyntax // var is child of ArgumentSyntax, eg. Goo(out var $$ 142?? token.Parent.Parent?.Parent as ArgumentSyntax; // var is child of DeclarationExpression 314v => v.Parent is FieldDeclarationSyntax f ? f.Modifiers : null, 353modifierGetter: v => v.Parent is LocalDeclarationStatementSyntax localDeclaration 392modifierGetter: v => v.Parent is UsingStatementSyntax or ForStatementSyntax 474parent is TypeArgumentListSyntax { Parent: GenericNameSyntax genericName })

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

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

Completion\CompletionProviders\ExplicitInterfaceMemberCompletionProvider.cs (1)

93ancestor = ancestor.Parent;

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 (1)

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\XmlDocCommentCompletionProvider.cs (3)

236(elementName, attributes) = GetElementNameAndAttributes(token.Parent.Parent!); 250(elementName, attributes) = GetElementNameAndAttributes(attributeSyntax.Parent!); 295token.Parent?.Parent is XmlNameAttributeSyntax xmlName)

Completion\KeywordRecommenders\AssemblyKeywordRecommender.cs (2)

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\WhereKeywordRecommender.cs (1)

76else if (tokenParent.Parent is LocalFunctionStatementSyntax { TypeParameterList.Parameters.Count: > 0 })

ConvertIfToSwitch\CSharpConvertIfToSwitchCodeRefactoringProvider.cs (1)

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

ConvertLinq\ConvertForEachToLinqQuery\CSharpConvertForEachToLinqQueryProvider.cs (1)

293block.Parent == memberDeclarationSyntax)

ConvertLinq\CSharpConvertLinqQueryToForEachProvider.cs (5)

213var identifier = ((QueryBodySyntax)selectClause.Parent).Continuation.Identifier; 263currentNode = currentNode.Parent; 279if (memberAccessExpression.Parent is InvocationExpressionSyntax invocationExpression) 471((VariableDeclarationSyntax)variableDeclarator.Parent).Type, 946node = node.Parent;

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (4)

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)

127if (current is { Parent.Parent: RecordDeclarationSyntax }) 137Debug.Assert(current.Parent.IsKind(SyntaxKind.VariableDeclaration)); 139switch (current.Parent.Parent!.Kind()) 147current = current.Parent; 152if (current.Parent is (kind: SyntaxKind.PropertyDeclaration or SyntaxKind.IndexerDeclaration)) 161Debug.Assert(current.Parent.IsKind(SyntaxKind.CompilationUnit)); 162declarations = new(current.Parent); 166current = current.Parent; 299node = node.Parent!; 302partnerStatement = partnerStatement.Parent; 376ParameterListSyntax parameters => parameters.Parent!, 392current = current.Parent; 409AccessorDeclarationSyntax { Parent.Parent: IndexerDeclarationSyntax { ParameterList: var list } } => list, 410ArrowExpressionClauseSyntax { Parent: { } memberDecl } => GetDeclarationParameterList(memberDecl), 421(oldBody.Parent.IsKind(SyntaxKind.LocalFunctionStatement) && newBody.Parent.IsKind(SyntaxKind.LocalFunctionStatement))) 442var parent = body.Parent!; 445return parent.IsKind(SyntaxKind.ArrowExpressionClause) && parent.Parent.IsKind(SyntaxKind.LocalFunctionStatement) ? parent.Parent : parent; 643case SyntaxKind.ParameterList when node.Parent is TypeDeclarationSyntax typeDeclaration: 679var parent = statement.Parent; 771if (oldStatement.Parent is UsingStatementSyntax oldUsing) 773return newStatement.Parent is UsingStatementSyntax newUsing && 914=> node is CompilationUnitSyntax ? null : node.Parent!.FirstAncestorOrSelf<BaseTypeDeclarationSyntax>(); 925return declaration.Parent?.Parent is not FieldDeclarationSyntax fieldDeclaration || 933=> declaration.Parent is TypeDeclarationSyntax { ParameterList: var parameterList } && parameterList == declaration; 1016Contract.ThrowIfNull(declaration.Parent); 1017var recordType = (INamedTypeSymbol?)model.GetDeclaredSymbol(declaration.Parent, cancellationToken); 1019return recordType.InstanceConstructors.Single(ctor => ctor.DeclaringSyntaxReferences is [var syntaxRef] && syntaxRef.GetSyntax(cancellationToken) == declaration.Parent); 1112if (oldNode is ParameterSyntax { Parent.Parent: RecordDeclarationSyntax } || 1113newNode is ParameterSyntax { Parent.Parent: RecordDeclarationSyntax }) 1308Debug.Assert(node.Parent.IsKind(SyntaxKind.AccessorList)); 1310if (HasEdit(editMap, node.Parent, editKind) && !HasEdit(editMap, node.Parent.Parent, editKind)) 1408Contract.ThrowIfNull(node.Parent); 1409node = node.Parent; 1435if (declaration is BaseParameterListSyntax and not { Parent: TypeDeclarationSyntax }) 1437declaration = declaration.Parent; 1443=> node is TypeParameterSyntax ? node.Parent!.Parent! : node!.Parent!; 1668return TryGetDiagnosticSpanImpl(node.Parent!, editKind); 1731return TryGetDiagnosticSpanImpl(node.Parent!, editKind); 1750return TryGetDiagnosticSpanImpl(node.Parent!, editKind); 1874return TryGetDiagnosticSpanImpl(queryBody.Clauses.FirstOrDefault() ?? queryBody.Parent!, editKind); 2047return TryGetDisplayNameImpl(node.Parent!, editKind); 2078if (node.Parent!.Parent!.IsKind(SyntaxKind.PropertyDeclaration)) 2084RoslynDebug.Assert(node.Parent.Parent.IsKind(SyntaxKind.IndexerDeclaration)); 2090if (node.Parent!.Parent!.IsKind(SyntaxKind.PropertyDeclaration)) 2096RoslynDebug.Assert(node.Parent.Parent.IsKind(SyntaxKind.IndexerDeclaration)); 2105return node.Parent!.Kind() switch 2123return node.Parent is TypeDeclarationSyntax ? FeaturesResources.constructor : null; 2266RoslynDebug.Assert(((LocalDeclarationStatementSyntax)node.Parent!.Parent!).AwaitKeyword.IsKind(SyntaxKind.AwaitKeyword)); 2410if (node.IsParentKind(SyntaxKind.CompilationUnit) || node.Parent.IsParentKind(SyntaxKind.CompilationUnit)) 2436if (oldNode.IsParentKind(SyntaxKind.CompilationUnit) || oldNode.Parent.IsParentKind(SyntaxKind.CompilationUnit)) 2459if (newNode.IsParentKind(SyntaxKind.CompilationUnit) || newNode.Parent.IsParentKind(SyntaxKind.CompilationUnit)) 2594RoslynDebug.Assert(current.Parent is object); 2595RoslynDebug.Assert(current.Parent.Kind() == SyntaxKind.TryStatement); 2596current = current.Parent; 2614Debug.Assert(current.Parent != null); 2615current = current.Parent; 2699tryStatement = (TryStatementSyntax)node.Parent!; 2740RoslynDebug.Assert(node.Parent is object); 2741switch (node.Parent.Kind()) 2760node = node.Parent; 2794return awaitExpression.Parent!.Parent!.Parent == containingStatementPart; 2799return awaitExpression.Parent!.Parent!.Parent!.Parent == containingStatementPart; 2867if (oldActiveStatement.Parent!.Parent!.Parent is not SwitchStatementSyntax oldSwitch) 2873var newSwitch = (SwitchStatementSyntax)newActiveStatement.Parent!.Parent!.Parent!; 2963node = node.Parent;

EditAndContinue\DeclarationBody\CSharpLambdaBody.cs (1)

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

EditAndContinue\DeclarationBody\FieldWithInitializerDeclarationBody.cs (2)

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

EditAndContinue\SyntaxComparer.cs (26)

245if (node != null && node.Parent.IsKind(SyntaxKind.ForStatement) && node is ExpressionSyntax) 467if (node == null || node.Parent.IsKind(SyntaxKind.QueryExpression)) 633if (node?.Parent is (kind: SyntaxKind.PropertyDeclaration or SyntaxKind.IndexerDeclaration)) 677if (node is { Parent: { } parent } && parent.IsParentKind(SyntaxKind.CompilationUnit)) 1038if (leftBlock.Parent == null || 1039rightBlock.Parent == null || 1040leftBlock.Parent.IsKind(SyntaxKind.ConstructorDeclaration) || 1041rightBlock.Parent.IsKind(SyntaxKind.ConstructorDeclaration)) 1047if (GetLabel(leftBlock.Parent) != GetLabel(rightBlock.Parent)) 1053switch (leftBlock.Parent.Kind()) 1070distance = GetDistance(leftBlock.Parent, rightBlock.Parent); 1074var leftCatch = (CatchClauseSyntax)leftBlock.Parent; 1075var rightCatch = (CatchClauseSyntax)rightBlock.Parent; 1079var leftTry = (TryStatementSyntax)leftCatch.Parent!; 1080var rightTry = (TryStatementSyntax)rightCatch.Parent!; 1088distance = GetDistance(leftBlock.Parent, rightBlock.Parent); 1109throw ExceptionUtilities.UnexpectedValue(leftBlock.Parent.Kind()); 1118if (leftNode.Parent != null && 1119rightNode.Parent != null && 1120GetLabel(leftNode.Parent) == GetLabel(rightNode.Parent)) 1122parentDistance = 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 } 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; 153=> field.Parent is TypeDeclarationSyntax;

ExtractMethod\CSharpMethodExtractor.Analyzer.cs (3)

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

ExtractMethod\CSharpMethodExtractor.cs (3)

107return globalStatement.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.ExpressionCodeGenerator.cs (8)

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;

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

75GlobalStatementSyntax globalStatement => ((CompilationUnitSyntax)globalStatement.Parent).Members.OfType<GlobalStatementSyntax>().Select(globalStatement => globalStatement.Statement),

ExtractMethod\CSharpSelectionResult.cs (3)

129Contract.ThrowIfFalse(last.Parent.IsParentKind(SyntaxKind.CompilationUnit)); 130return last.Parent.Parent;

ExtractMethod\CSharpSelectionResult.ExpressionResult.cs (1)

75if (node.Parent is CastExpressionSyntax castExpression)

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 (35)

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)

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (1)

48if (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 })

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)

58{ Parent: PragmaWarningDirectiveTriviaSyntax } node => node, 100Parent: AttributeArgumentListSyntax 103Parent: AttributeSyntax

QuickInfo\CSharpSemanticQuickInfoProvider.cs (2)

60token.Parent?.Parent.IsKind(SyntaxKind.ElementAccessExpression) == true) 62found = token.Parent.Parent;

QuickInfo\CSharpSyntacticQuickInfoProvider.cs (2)

88spanStart = parent.Parent!.SpanStart; 98&& 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\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 (1)

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)

43=> 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 (1)

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)) 105while (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\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 (8)

460if (memberAccess.Parent is InvocationExpressionSyntax invocationExpression) 496if (locallyScopedExpression.Parent is EqualsValueClauseSyntax { Parent: VariableDeclaratorSyntax declarator }) 585if (argument.Parent is not BaseArgumentListSyntax { Parent: ExpressionSyntax parentInvocation } argumentList) 659Contract.ThrowIfFalse(originalInitializer.Parent 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 (9)

93if (localDeclaration.Parent is not BlockSyntax block) 216Parent: EqualsValueClauseSyntax 218Parent: VariableDeclaratorSyntax 220Parent: VariableDeclarationSyntax 222Parent: LocalDeclarationStatementSyntax declaration, 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\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 (2)

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 (2)

184(expression.Parent as AssignmentExpressionSyntax)?.Parent as ExpressionStatementSyntax)

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 (2)

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\CSharpImplementInterfaceCodeFixProvider.cs (2)

29=> type.Parent is BaseTypeSyntax { Parent: BaseListSyntax } baseTypeParent && baseTypeParent.Type == type;

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

48if (node is TypeSyntax interfaceNode && interfaceNode.Parent is BaseTypeSyntax baseType && 49baseType.Parent is BaseListSyntax baseList &&

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

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 (1)

46if (declarationPattern.Parent is IsPatternExpressionSyntax isPattern)

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

82if (statement.Parent?.Kind()

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\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\UseImplicitOrExplicitType\UseExplicitTypeCodeFixProvider.cs (4)

58var declarationContext = node.Parent; 62declarationContext = declarationContext.Parent; 92RoslynDebug.AssertNotNull(typeSyntax.Parent); 94var 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)

43var 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\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)

203if (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,

UseAutoProperty\UseAutoPropertyRewriter.cs (2)

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

UseExpressionBody\UseExpressionBodyCodeRefactoringProvider.cs (2)

150for (var current = node; current != null; current = current.Parent) 176? 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)

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