Span

RuntimeSource\Configuration.Binder\Specs\InterceptorInfo.cs (1)

180TextSpan memberNameSpan = memberAccessExprSyntax.Name.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationHelpers.cs (1)

221var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= info.Context.BeforeThisLocation.SourceSpan.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (6)

48if (selection.IsEmpty || node.Span.IsEmpty) 54if (selection.Contains(node.Span)) 81var beginningNode = node.FindToken(node.Span.Start).Parent; 82var endNode = node.FindToken(node.Span.End - 1).Parent; 93return beginningNode.Span.End <= selection.Start || endNode.Span.Start >= selection.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

172var affectedSpan = TextSpan.FromBounds(previousToken.SpanStart, FirstStatementAffectedInInnermostBlock.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsService.cs (3)

44=> x?.Span == y?.Span; 47=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

71return !semanticModel.SyntaxTree.OverlapsHiddenPosition(memberAccessExpression.Span, cancellationToken) &&

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NullableHelpers.cs (3)

43semanticFacts, semanticModel, rootOperation, declaredSymbol, rootOperation.Syntax.Span, includeDeclaration: true, cancellationToken) == true; 67if (!span.IntersectsWith(operation.Syntax.Span)) 70if (span.Contains(operation.Syntax.Span) &&

InheritanceMargin\BenchmarksHelpers.cs (1)

29document, root.Span, includeGlobalImports: true, frozenPartialSemantics: true, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

CallAnalysis\Fixers\LegacyLoggingFixer.cs (1)

326return (doc, (root!.FindNode(invocationExpression.Span) as ExpressionSyntax)!);

Infrastructure\VirtualChars\CSharpVirtualCharService.cs (1)

200var indentationLength = parentSourceText.Lines.GetLineFromPosition(parentExpression.Span.End).GetFirstNonWhitespaceOffset() ?? 0;

StaticRouteHandlerModel\Endpoint.cs (1)

162var invocationNameSpan = memberAccessorExpression.Name.Span;

Diagnostic\SourceLocation.cs (1)

27: this(node.SyntaxTree, node.Span)

DiagnosticAnalyzer\AnalysisContextInfo.cs (3)

112var lineSpan = text?.Lines?.GetLinePositionSpan(_node.Span); 115sb.AppendLine($"{nameof(SyntaxNode)}: {GetFlattenedNodeText(_node)} [{_node.GetType().Name}]@{_node.Span} {(lineSpan.HasValue ? lineSpan.Value.ToString() : string.Empty)}"); 125var lastEnd = node.Span.Start;

DiagnosticAnalyzer\AnalyzerExecutor.cs (2)

1515_isGeneratedCodeLocation(node.SyntaxTree, node.Span, cancellationToken)) 1527_isGeneratedCodeLocation(operation.Syntax.SyntaxTree, operation.Syntax.Span, cancellationToken))

Operations\OperationExtensions.cs (1)

63return model.GetDiagnostics(operation.Syntax.Span, cancellationToken).Any(static d => d.DefaultSeverity == DiagnosticSeverity.Error);

Syntax\SyntaxList`1.cs (2)

186return TextSpan.FromBounds(this[0].Span.Start, this[this.Count - 1].Span.End);

Syntax\SyntaxNode.cs (2)

114/// Same as accessing <see cref="TextSpan.Start"/> on <see cref="Span"/>. 676return this.SyntaxTree.GetLocation(this.Span);

Syntax\SyntaxNodeOrToken.cs (1)

238return _nodeOrParent.Span;

Syntax\SyntaxNodeOrTokenList.cs (1)

173public TextSpan Span => _node?.Span ?? default(TextSpan);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationHelpers.cs (1)

221var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= info.Context.BeforeThisLocation.SourceSpan.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (6)

48if (selection.IsEmpty || node.Span.IsEmpty) 54if (selection.Contains(node.Span)) 81var beginningNode = node.FindToken(node.Span.Start).Parent; 82var endNode = node.FindToken(node.Span.End - 1).Parent; 93return beginningNode.Span.End <= selection.Start || endNode.Span.Start >= selection.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

172var affectedSpan = TextSpan.FromBounds(previousToken.SpanStart, FirstStatementAffectedInInnermostBlock.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsService.cs (3)

44=> x?.Span == y?.Span; 47=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

71return !semanticModel.SyntaxTree.OverlapsHiddenPosition(memberAccessExpression.Span, cancellationToken) &&

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NullableHelpers.cs (3)

43semanticFacts, semanticModel, rootOperation, declaredSymbol, rootOperation.Syntax.Span, includeDeclaration: true, cancellationToken) == true; 67if (!span.IntersectsWith(operation.Syntax.Span)) 70if (span.Contains(operation.Syntax.Span) &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationHelpers.cs (1)

221var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= info.Context.BeforeThisLocation.SourceSpan.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (6)

48if (selection.IsEmpty || node.Span.IsEmpty) 54if (selection.Contains(node.Span)) 81var beginningNode = node.FindToken(node.Span.Start).Parent; 82var endNode = node.FindToken(node.Span.End - 1).Parent; 93return beginningNode.Span.End <= selection.Start || endNode.Span.Start >= selection.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

172var affectedSpan = TextSpan.FromBounds(previousToken.SpanStart, FirstStatementAffectedInInnermostBlock.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsService.cs (3)

44=> x?.Span == y?.Span; 47=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

71return !semanticModel.SyntaxTree.OverlapsHiddenPosition(memberAccessExpression.Span, cancellationToken) &&

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NullableHelpers.cs (3)

43semanticFacts, semanticModel, rootOperation, declaredSymbol, rootOperation.Syntax.Span, includeDeclaration: true, cancellationToken) == true; 67if (!span.IntersectsWith(operation.Syntax.Span)) 70if (span.Contains(operation.Syntax.Span) &&

src\Analyzers\Core\Analyzers\PopulateSwitch\AbstractPopulateSwitchDiagnosticAnalyzer.cs (1)

66if (switchBlock.SyntaxTree.OverlapsHiddenPosition(switchBlock.Span, context.CancellationToken))

src\Analyzers\Core\Analyzers\RemoveUnnecessaryCast\AbstractRemoveUnnecessaryCastDiagnosticAnalyzer.cs (1)

66if (tree.OverlapsHiddenPosition(node.Span, cancellationToken))

src\Analyzers\Core\Analyzers\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (3)

153textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 167textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 181var end = node.Span.End;

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (1)

129if (memberDecl != null && !context.ShouldAnalyzeSpan(memberDecl.Span))

src\Analyzers\Core\Analyzers\SimplifyInterpolation\AbstractSimplifyInterpolationHelpers.cs (3)

109unnecessarySpans.AddRange(invocation.Syntax.Span 124unnecessarySpans.AddRange(invocation.Syntax.Span 234unnecessarySpans.AddRange(invocation.Syntax.Span

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (1)

205if (node is TPropertyDeclaration or TFieldDeclaration && context.ShouldAnalyzeSpan(node.Span, node.SyntaxTree))

src\Analyzers\Core\Analyzers\UseCollectionInitializer\UseCollectionInitializerHelpers.cs (2)

37syntaxTree.GetLocation(TextSpan.FromBounds(arguments.Last().FullSpan.End, match.Span.End))); 49syntaxTree.GetLocation(TextSpan.FromBounds(expression.FullSpan.End, match.Span.End)));

src\Analyzers\Core\Analyzers\UseObjectInitializer\AbstractUseObjectInitializerDiagnosticAnalyzer.cs (3)

150: syntaxFacts.GetExpressionOfMemberAccessExpression(match.MemberAccessExpression)!.Span.End; 156if (match.Statement.Span.End > match.Initializer.FullSpan.End) 158locations.Add(syntaxTree.GetLocation(TextSpan.FromBounds(match.Initializer.FullSpan.End, match.Statement.Span.End)));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\Analyzers\Core\CodeFixes\AddAnonymousTypeMemberName\AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs (1)

58if (node?.Span != span)

src\Analyzers\Core\CodeFixes\AddExplicitCast\Fixer.cs (1)

211if (newRoot.FindNode(targetNode.Span).GetAncestorOrThis<TArgumentListSyntax>() is TArgumentListSyntax newArgumentList)

src\Analyzers\Core\CodeFixes\ConvertToAsync\AbstractConvertToAsyncCodeFixProvider.cs (1)

47node = ancestors.FirstOrDefault(n => n.Span.Contains(span) && n != root);

src\Analyzers\Core\CodeFixes\Iterator\AbstractIteratorCodeFixProvider.cs (1)

44node = ancestors.FirstOrDefault(n => n.Span.Contains(span) && n != root);

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

846var spansToFormat = originalDeclStatementsToMoveOrRemove.Select(s => s.Span);

src\Analyzers\Core\CodeFixes\UseConditionalExpression\AbstractUseConditionalExpressionCodeFixProvider.cs (3)

156if (condition.Span.Length + trueSyntax.Span.Length + falseSyntax.Span.Length > formattingOptions.ConditionalExpressionWrappingLength)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationHelpers.cs (1)

221var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= info.Context.BeforeThisLocation.SourceSpan.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (6)

48if (selection.IsEmpty || node.Span.IsEmpty) 54if (selection.Contains(node.Span)) 81var beginningNode = node.FindToken(node.Span.Start).Parent; 82var endNode = node.FindToken(node.Span.End - 1).Parent; 93return beginningNode.Span.End <= selection.Start || endNode.Span.Start >= selection.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

172var affectedSpan = TextSpan.FromBounds(previousToken.SpanStart, FirstStatementAffectedInInnermostBlock.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsService.cs (3)

44=> x?.Span == y?.Span; 47=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

71return !semanticModel.SyntaxTree.OverlapsHiddenPosition(memberAccessExpression.Span, cancellationToken) &&

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NullableHelpers.cs (3)

43semanticFacts, semanticModel, rootOperation, declaredSymbol, rootOperation.Syntax.Span, includeDeclaration: true, cancellationToken) == true; 67if (!span.IntersectsWith(operation.Syntax.Span)) 70if (span.Contains(operation.Syntax.Span) &&

Binder\Binder_Expressions.cs (1)

5362var end = analyzedArguments.Arguments[analyzedArguments.Arguments.Count - 1].Syntax.Span.End;

Binder\BinderFactory.BinderFactoryVisitor.cs (1)

1065TextSpan containingSpan = containingNode.Span;

CodeGen\CodeGenerator.cs (1)

493EmitSequencePoint(syntax.SyntaxTree, syntax.Span);

Compilation\CSharpCompilation.cs (4)

244return IsNullableAnalysisEnabledIn((CSharpSyntaxTree)syntax.SyntaxTree, syntax.Span); 2801TryAdd(new ImportInfo(syntax.SyntaxTree, syntax.Kind(), syntax.Span), default); 4622return loc1.Span.Start - loc2.Span.Start;

Compilation\CSharpSemanticModel.cs (2)

1325if (betterPosition < node.Span.End) 2219var binder = this.GetEnclosingBinder(boundExpr.Syntax.Span.Start);

Compilation\SpeculativeSemanticModelWithMemberModel.cs (3)

155!Root.Span.Contains(attributeOrParameter.Span)) 189if (defaultValueSyntax != null && defaultValueSyntax.FullSpan.Contains(node.Span))

Compilation\SyntaxTreeSemanticModel.cs (5)

773return ((CSharpSyntaxTree)speculativeSyntax.SyntaxTree).IsNullableAnalysisEnabled(speculativeSyntax.Span) ?? 849var span = node.Span; 1431return GetDeclaredMember(container, declarationSyntax.Span, isKnownToBeANamespace: false, name) as NamedTypeSymbol; 1620return (this.GetDeclaredMember(container, declarationSyntax.Span, isKnownToBeANamespace: false) as MethodSymbol).GetPublicSymbol(); 2407return this.GetDeclaredMember(container, declarationSyntax.Span, isKnownToBeANamespace: false, name);

Compiler\UnprocessedDocumentationCommentFinder.cs (1)

56if (node.Span.Length > 0)

FlowAnalysis\AbstractFlowPass.cs (1)

202int endLocation = lastInRegion.Syntax.Span.End;

FlowAnalysis\AlwaysAssignedWalker.cs (3)

85if (IsInside && pending.Branch != null && !RegionContains(pending.Branch.Syntax.Span)) 107if (node.Syntax != null && RegionContains(node.Syntax.Span)) _labelsInside.Add(label); 137if (branch.Branch != null && RegionContains(branch.Branch.Syntax.Span) && !_labelsInside.Contains(branch.Label))

FlowAnalysis\ControlFlowPass.cs (1)

265statement.Syntax.Span.Length != 0)

FlowAnalysis\DataFlowsInWalker.cs (4)

85if (!gotoStmt.WasCompilerGenerated && !targetStmt.WasCompilerGenerated && !RegionContains(gotoStmt.Syntax.Span) && RegionContains(targetStmt.Syntax.Span)) 106if (RegionContains(node.Span)) 121if (node != null && node is ReturnStatementSyntax && RegionContains(node.Span))

FlowAnalysis\DefiniteAssignment.cs (1)

1218(symbol.TryGetFirstLocation() is var location && (location is null || node.Span.End < location.SourceSpan.Start)))

FlowAnalysis\EntryPointsWalker.cs (2)

62if (!gotoStmt.WasCompilerGenerated && !targetStmt.WasCompilerGenerated && RegionContains(targetStmt.Syntax.Span) && !RegionContains(gotoStmt.Syntax.Span))

FlowAnalysis\ExitPointsWalker.cs (1)

124if (pending.Branch == null || !RegionContains(pending.Branch.Syntax.Span)) continue;

FlowAnalysis\ReadWriteWalker.cs (10)

147if (!IsInside && node.Span.Contains(RegionSpan) && (expr.Kind == BoundKind.FieldAccess)) 191if (RegionContains(receiverSyntax.Span)) 197if (RegionContains(receiverSyntax.Span)) 203if (RegionContains(receiverSyntax.Span)) 209if (RegionContains(receiverSyntax.Span)) 215if (RegionContains(receiverSyntax.Span)) 221if (receiver.Type.IsStructType() && receiverSyntax.Span.OverlapsWith(RegionSpan)) 227if (receiverSyntax.Span.OverlapsWith(RegionSpan)) 259if (!IsInside && node.Syntax != null && node.Syntax.Span.Contains(RegionSpan)) 269if (!IsInside && node.Syntax != null && node.Syntax.Span.Contains(RegionSpan))

FlowAnalysis\RegionAnalysisContext.cs (1)

45firstInRegion.Syntax.SpanStart > lastInRegion.Syntax.Span.End;

Lowering\Instrumentation\CodeCoverageInstrumenter.cs (2)

620return syntax.Span; 627var originalSpan = syntax.Span;

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

31(node, level) => !node.Span.OverlapsWith(span) || InvalidLevel(level),

Symbols\NamespaceOrTypeSymbol.cs (1)

228if (loc.IsInSource && loc.SourceTree == syntax.SyntaxTree && syntax.Span.Contains(loc.SourceSpan))

Symbols\Source\SourceConstructorSymbolBase.cs (1)

205span = ctorInitializer.Span;

Syntax\SimpleSyntaxReference.cs (1)

34return _node.Span;

Syntax\SyntaxNodeRemover.cs (3)

306this.AddDirectives(node, GetRemovedSpan(node.Span, node.FullSpan)); 344var span = TextSpan.FromBounds(token.Span.Start, node.Span.End); 378var span = TextSpan.FromBounds(node.Span.Start, token.Span.End);

Syntax\SyntaxReplacer.cs (1)

422: base(originalNode.Span, editKind, false, originalNode.IsPartOfStructuredTrivia())

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

41if (!context.ShouldAnalyzeSpan(member.Span))

src\Analyzers\CSharp\Analyzers\AddBraces\CSharpAddBracesDiagnosticAnalyzer.cs (2)

132var ifStatementSpanWithoutElse = TextSpan.FromBounds(statement.Span.Start, embeddedStatement.Span.End);

src\Analyzers\CSharp\Analyzers\ConvertNamespace\ConvertToFileScopedNamespaceDiagnosticAnalyzer.cs (1)

57: declaration.SyntaxTree.GetLocation(TextSpan.FromBounds(declaration.SpanStart, declaration.Name.Span.End));

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

151if (!context.ShouldAnalyzeSpan(localDeclaration.Span)) 335var localStatementStart = localStatement.Span.Start; 336var argumentNodeStart = argumentNode.Span.Start; 344var descendentStart = descendentNode.Span.Start;

src\Analyzers\CSharp\Analyzers\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessAnalyzer.cs (4)

136[Location.Create(tree, ifStatement.Span), Location.Create(tree, expressionStatement.Span)], 202if (nextToken.Span.Start < ifStatement.Span.End) 204fadeLocation = Location.Create(tree, TextSpan.FromBounds(nextToken.Span.Start, ifStatement.Span.End));

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryCast\CSharpRemoveUnnecessaryCastDiagnosticAnalyzer.cs (1)

32BinaryExpressionSyntax binary => TextSpan.FromBounds(binary.OperatorToken.SpanStart, node.Span.End),

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

231var endReportSpan = TextSpan.FromBounds(invokedExpression.Span.End, anonymousFunction.Span.End);

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\CSharpRemoveUnnecessaryNullableDirectiveDiagnosticAnalyzer.cs (6)

127|| !possibleNullableImpactIntervalTree.HasIntervalThatOverlapsWith(currentOptionsDirective.Span.End, nullableDirectiveTrivia.SpanStart - currentOptionsDirective.Span.End)) 148possibleNullableImpactIntervalTree.AddIntervalInPlace(directive.Span); 159|| !possibleNullableImpactIntervalTree.HasIntervalThatOverlapsWith(currentOptionsDirective.Span.End, root.Span.End - currentOptionsDirective.Span.End))

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

47if (node.Span.End < _positionOfFirstReducingNullableDirective) 52if (_ignoredSpans.HasIntervalThatContains(node.SpanStart, node.Span.Length)) 135SpansBuilder.Add(predefinedType.Span); 153SpansBuilder.Add(node.Span);

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

221? arrayCreationExpression.Type.Span.End

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

302text.Lines.GetLineFromPosition(expression.SpanStart).LineNumber + 1 == text.Lines.GetLineFromPosition(expression.Span.End).LineNumber &&

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

112expression.Type.Span.End)));

src\Analyzers\CSharp\Analyzers\UseImplicitOrExplicitType\CSharpTypeStyleDiagnosticAnalyzerBase.cs (1)

55context.ReportDiagnostic(CreateDiagnostic(descriptor, declarationStatement, declaredType.StripRefIfNeeded().Span, typeStyle.Notification, context.Options));

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseRangeOperatorDiagnosticAnalyzer.cs (1)

319TextSpan.FromBounds(arguments.First().SpanStart, arguments.Last().Span.End));

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

180if (context.ShouldAnalyzeSpan(localDeclaration.Span)) 184&& context.ShouldAnalyzeSpan(anonymousFunctionStatement!.Span)) 247var descendentStart = descendentNode.Span.Start;

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

160if (forStatement.Condition is null || !forStatement.Condition.Span.Contains(_comparison.Span)) 256if (node.SpanStart < _localStatement.Span.End) 260if (node.Span.End >= _comparison.SpanStart) 354var scopeSpan = scope.Span; 368if (descendentNodeSpanStart >= comparisonSpanStart && scopeSpan.Contains(descendentNode.Span))

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

117if (!syntaxContext.ShouldAnalyzeSpan(localStatement.Span)) 217descendentNode.Span.IntersectsWith(comparisonEnclosingBlock.Span) &&

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

83if (!syntaxContext.ShouldAnalyzeSpan(localDeclarationStatement.Span))

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

123var span = TextSpan.FromBounds(elements[0].Syntax.SpanStart, elements[^1].Syntax.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\EmbeddedLanguages\VirtualChars\CSharpVirtualCharService.cs (1)

188var indentationLength = parentSourceText.Lines.GetLineFromPosition(parentExpression.Span.End).GetFirstNonWhitespaceOffset() ?? 0;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\BlockSyntaxExtensions.cs (3)

73conditionalDirectives.Last().Span.End >= block.CloseBraceToken.Span.End) 79if (conditionalDirectives.Last().Span.End <= statement.Span.Start)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs (1)

561var matchSpan = match.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\CSharpTriviaFormatter.DocumentationCommentExteriorCommentRewriter.cs (1)

75trivia.Span.End == currentParent.Span.End)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (2)

711if (useFullSpan || node.Span.Contains(position)) 919if (node.Span.IsEmpty)

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

97var indentation = sourceText.GetLeadingWhitespaceOfLineAtPosition(node.Span.Start);

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

141foreach (var container in unassignedParameters.Keys.OrderByDescending(n => n.Span.Start))

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

165lastRawStringLiteralData = (stringNode, ComputeCommonIndentationLength(text.Lines.GetLineFromPosition(stringNode.Span.End)));

src\Analyzers\CSharp\CodeFixes\Iterator\CSharpAddYieldCodeFixProvider.cs (2)

107var symbol = model.GetEnclosingSymbol(node.Span.Start, cancellationToken); 220node = ancestors.FirstOrDefault(n => n.Span.Contains(span) && n != root && n.IsKind(SyntaxKind.ReturnStatement));

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

733totalLength += expression.Span.Length; 762totalLength += component.Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\CompilationUnitSyntaxExtensions.cs (3)

43var end = usings.Last().Span.End; 52var end = rootUsings.Last().Span.End; 60: root.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\CSharpSyntaxContext.cs (1)

503lockStatement.Statement.Span.Contains(position))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\SyntaxTreeExtensions.cs (1)

683return declaration?.Name.Span.IntersectsWith(position) == true;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\TypeDeclarationSyntaxExtensions.cs (1)

46start = members.Last().Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpRemoveUnnecessaryImportsService.cs (1)

67spansToFormat.Add(TextSpan.FromBounds(baseNamespace.Name.Span.End, firstMemberB.SpanStart));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)

2217if (descendant.SpanStart <= afterNode.Span.End)

AutomaticCompletion\AutomaticLineEnderCommandHandler.cs (2)

238if (embeddedStatement == null || embeddedStatement.Span.IsEmpty) 613IndexerDeclarationSyntax indexerNode => indexerNode.ParameterList.Span.End,

AutomaticCompletion\AutomaticLineEnderCommandHandler_Helpers.cs (12)

CompleteStatement\CompleteStatementCommandHandler.cs (13)

234var newCaretPosition = currentNode.Span.End; 316return (caret >= condition.Span.Start && caret <= condition.Span.End); 410forStatementCaret = GetCaretAtPosition(condition.Span.End); 414forStatementCaret = GetCaretAtPosition(declaration.Span.End); 440return caretPosition > condition.SpanStart && caretPosition <= condition.Span.End; 449return caretPosition > declaration.Span.Start && caretPosition <= declaration.Span.End; 467relocatedPosition = forStatementSyntax.Initializers[separatorIndex].Span.End; 502return caret.Position <= currentNode.Span.End; 508return caret.Position <= currentNode.Span.End; 514return caret.Position < currentNode.Span.End - 2; 517return caret.Position < currentNode.Span.End;

EventHookup\EventHookupCommandHandler_TabKeyCommand.cs (1)

233renameSpan = memberAccessExpression.Name.Span;

Interactive\CSharpSendToInteractiveSubmissionProvider.cs (5)

40? [expandedNode.Span] 73if (startNode.Span.Contains(endNode.Span)) 77else if (endNode.Span.Contains(startNode.Span))

RawStringLiteral\RawStringLiteralCommandHandler_Return.cs (2)

238var index = expression.Span.End; 250var index = expression.Span.Start;

RawStringLiteral\RawStringLiteralCommandHandler_TypeChar.cs (1)

239return new TextChange(new TextSpan(token.GetRequiredParent().Span.End, 0), "\"");

StringCopyPaste\KnownSourcePasteProcessor.cs (4)

188edits.Add(new TextChange(new TextSpan(StringExpressionBeforePaste.Span.Start, 0), dollarSignsToAdd)); 231if (beforeSelection && interpolation.Span.End > _selectionSpanBeforePaste.Start) 234if (!beforeSelection && interpolation.Span.Start < _selectionSpanBeforePaste.End) 335if (line == TextBeforePaste.Lines.GetLineFromPosition(StringExpressionBeforePaste.Span.End).LineNumber)

StringCopyPaste\StringCopyPasteCommandHandler.cs (4)

245var lastLine = textBeforePaste.Lines.GetLineFromPosition(stringExpressionBeforePaste.Span.End); 277var spanAfterPaste = MapSpan(stringExpressionBeforePaste.Span, snapshotBeforePaste, snapshotAfterPaste); 278return spanAfterPaste == stringExpressionAfterPaste.Span; 298var spanAfterPaste = MapSpan(stringExpressionBeforePaste.Span, snapshotBeforePaste, snapshotAfterPaste);

StringCopyPaste\StringCopyPasteData.cs (2)

150if (interpolatedContent.Span.OverlapsWith(selectionSpan)) 156if (!selectionSpan.Contains(interpolation.Span))

StringCopyPaste\StringInfo.cs (8)

91var end = SkipU8Suffix(text, literal.Span.End); 105endDelimiterSpan: TextSpan.FromBounds(end, literal.Span.End), 146TextSpan.FromBounds(rawEnd, literal.Span.End), 167var end = SkipU8Suffix(text, literal.Span.End); 176endDelimiterSpan: TextSpan.FromBounds(end, literal.Span.End), 197var end = SkipU8Suffix(text, interpolatedString.Span.End); 210currentPosition = content.Span.End; 220endDelimiterSpan: TextSpan.FromBounds(interpolatedString.StringEndToken.SpanStart, interpolatedString.Span.End),

StringCopyPaste\UnknownSourcePasteProcessor.cs (3)

125edits.Add(new TextChange(new TextSpan(StringExpressionBeforePaste.Span.Start, 0), dollarSignsToAdd)); 230var endLine = TextBeforePaste.Lines.GetLineFromPosition(StringExpressionBeforePaste.Span.End); 321if (line == TextBeforePaste.Lines.GetLineFromPosition(StringExpressionBeforePaste.Span.End).LineNumber)

CodeActions\PreviewExceptionTests.cs (1)

109var span = document.GetSyntaxRootAsync().Result.Span;

CodeActions\PreviewTests.cs (1)

95var span = document.GetSyntaxRootAsync().Result.Span;

ExtractMethod\ExtractMethodBase.cs (1)

198var validator = new CSharpExtractMethodService.CSharpSelectionValidator(semanticDocument, node.Span, localFunction: false);

TypeInferrer\TypeInferrerTests.cs (2)

40inferredType = typeInference.InferType(await document.ReuseExistingSpeculativeModelAsync(node?.Span ?? textSpan, CancellationToken.None), node, objectAsDefault: true, cancellationToken: CancellationToken.None); 78if (currentNode is ExpressionSyntax result && result.Span == textSpan)

Diagnostics\DiagnosticAnalyzerTests.cs (1)

4326: localDeclaration.Span;

Diagnostics\GetDiagnosticsTests.cs (3)

908var span = localDecl.Span; 1187var span = localDecl.Span; 1678var result = await compilationWithAnalyzers.GetAnalysisResultAsync(model1, filterSpan: localDecl.Span, CancellationToken.None);

FlowAnalysis\FlowTestBase.cs (6)

147if (expr.SpanStart >= start && expr.Span.End <= end) 168if (expr.SpanStart >= start && expr.Span.End <= end) 200if (expr.SpanStart >= start && expr.Span.End <= end) 226if (firstStatement != null && stmt.Span.End <= end && stmt.Parent == firstStatement.Parent) 238return GetSyntaxNodeList(tree).OfType<T>().Where(n => n.Span.Contains(offset)).FirstOrDefault(); 244return GetSyntaxNodeList(tree).OfType<T>().Where(n => n.Span.Contains(offset)).Last();

FlowAnalysis\RegionAnalysisTests.cs (1)

7910Assert.Equal(0, stmt.Span.Length);

Semantics\ExtensionTests.cs (4)

4650model.GetDiagnostics(ext.ParameterList.Span).Verify( 4656model.GetDiagnostics(m.Body.Span).Verify( 4694model.GetDiagnostics(ext.ParameterList.Span).Verify( 4700model.GetDiagnostics(m.Body.Span).Verify(

Semantics\OutVarTests.cs (10)

1079if (typeofExpression?.Type?.FullSpan.Contains(decl.Span) == true) 1210if (dataFlowParent.Span.Contains(reference.Span) && reference.SpanStart > decl.SpanStart) 1261if (!dataFlowParent.Span.Contains(reference.Span)) 1298if (!dataFlowParent.Span.Contains(reference.Span) && 1299(containingReturnOrThrow == null || containingReturnOrThrow.Span.Contains(reference.SpanStart)) && 1319if (!dataFlowParent.Span.Contains(reference.Span))

ChangeSignature\CSharpChangeSignatureService.cs (2)

142if (!matchingNode.Span.IntersectsWith(position)) 178var argument = argumentList?.Arguments.FirstOrDefault(a => a.Span.Contains(position));

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (1)

63localFunction.Span);

CodeRefactorings\EnableNullable\EnableNullableCodeRefactoringProvider.cs (1)

248if (firstSemanticToken.IsKind(SyntaxKind.None) || firstSemanticToken.SpanStart > nullableDirective.Span.End)

CodeRefactorings\InlineTemporary\InlineTemporaryCodeRefactoringProvider.cs (4)

89if (references.Any(static (r, variableDeclarator) => variableDeclarator.Initializer.Span.Contains(r.Span), variableDeclarator)) 97variableDeclarator.Span); 443if (!text.AreOnSameLine(expression.SpanStart, expression.Span.End))

CodeRefactorings\SyncNamespace\CSharpChangeNamespaceService.cs (2)

59containerSpan = container.Span; 365if (!compilationUnit.Span.Contains(span))

CodeRefactorings\SyncNamespace\CSharpSyncNamespaceCodeRefactoringProvider.cs (1)

40if (namespaceDeclaration.Name.Span.IntersectsWith(position))

CodeRefactorings\UseExplicitOrImplicitType\AbstractUseTypeCodeRefactoringProvider.cs (1)

68declaredType.Span);

CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (1)

605if (!fixAllSpans.Any(fixAllSpan => fixAllSpan.Contains(originalNode.Span)))

Completion\CompletionProviders\AttributeNamedParameterCompletionProvider.cs (2)

207argumentList.Arguments.Where(a => a.Span.End <= position) 211argumentList.Arguments.Where(a => a.Span.End <= position)

Completion\CompletionProviders\AwaitCompletionProvider.cs (3)

74return new TextChange(existingReturnType.Span, newTypeName); 122return node.Span.Contains(position); 124return node.Span.IntersectsWith(position);

Completion\CompletionProviders\CompletionUtilities.cs (7)

194return methodDeclaration.ExpressionBody.Expression.Span; 199return methodDeclaration.Body.Statements.Last().Span; 203return methodDeclaration.Span; 213return new TextSpan(caretTarget.Span.End, 0); 225return firstAccessorStatement.Span; 230return expression.Span; 235return new TextSpan(propertyDeclaration.Span.End, 0);

Completion\CompletionProviders\ExplicitInterfaceTypeCompletionProvider.cs (1)

81if (typeNode.Parent is TypeSyntax parentType && parentType.Span.End < position)

Completion\CompletionProviders\NamedParameterCompletionProvider.cs (1)

144var existingArguments = argumentList.Arguments.Where(a => a.Span.End <= position && a.NameColon != null)

Completion\KeywordRecommenders\InKeywordRecommender.cs (1)

69if (statement != null && token.Span.End == statement.Variable.Span.End)

ConvertLinq\CSharpConvertLinqQueryToForEachProvider.cs (1)

93!_semanticModel.GetDiagnostics(_source.Span, _cancellationToken).Any(static diagnostic => diagnostic.DefaultSeverity == DiagnosticSeverity.Error))

ConvertNamespace\ConvertNamespaceCodeRefactoringProvider.cs (1)

82return position <= namespaceDeclaration.Name.Span.End;

ConvertToRawString\ConvertInterpolatedStringToRawStringCodeRefactoringProvider.cs (2)

357var interpolation = stringExpression.Contents.OfType<InterpolationSyntax>().Single(i => i.Span.Contains(start)); 505var descendantSpan = descendant.Span;

Copilot\CSharpCopilotCodeFixProvider.cs (1)

80if (containingMethod?.Span.IntersectsWith(context.Span) is true)

Debugging\DataTipInfoGetter.cs (6)

42return new DebugDataTipInfo(typeSyntax.Span, text); 54: new DebugDataTipInfo(expression.Span, type.ToNameDisplayString()); 67? expression.GetRequiredParent().Span 68: TextSpan.FromBounds(current.SpanStart, expression.Span.End); 78return new DebugDataTipInfo(expression.Span, fullExpressionSpan ?? expression.Span, Text: null, kind);

EditAndContinue\BreakpointSpans.cs (11)

179return (methodDeclaration.Body != null) ? CreateSpanForBlock(methodDeclaration.Body, position) : methodDeclaration.ExpressionBody?.Expression.Span; 343return property.ExpressionBody.Expression.Span; 349return property.Initializer.Value.Span; 364return indexer.ExpressionBody.Expression.Span; 445return constructorSyntax.ExpressionBody.Expression.Span; 458return constructorSyntax.ExpressionBody.Expression.Span; 487return TextSpan.FromBounds(typeDeclaration.Identifier.SpanStart, typeDeclaration.ParameterList.Span.End); 507=> baseTypeSyntax.Span; 546=> accessor.Span; 616if (position < doStatement.Statement.Span.Start) 682return ((ForEachVariableStatementSyntax)statement).Variable.Span;

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (39)

EditAndContinue\DeclarationBody\OrdinaryInstanceConstructorWithExplicitInitializerDeclarationBody.cs (1)

41=> TextSpan.FromBounds(InitializerActiveStatementSpan.Start, Body.Span.End);

EditAndContinue\DeclarationBody\OrdinaryInstanceConstructorWithImplicitInitializerDeclarationBody.cs (1)

35=> TextSpan.FromBounds(InitializerActiveStatementSpan.Start, Body.Span.End);

EditAndContinue\DeclarationBody\PropertyOrIndexerAccessorDeclarationBody.cs (1)

66=> ExplicitBody?.Span ?? HeaderActiveStatementSpan;

EditAndContinue\DeclarationBody\TopLevelCodeDeclarationBody.cs (1)

35=> TextSpan.FromBounds(unit.Members[0].SpanStart, GlobalStatements.Last().Span.End);

EncapsulateField\CSharpEncapsulateFieldService.cs (3)

129.DescendantNodes(d => d.Span.IntersectsWith(span)) 131.Where(n => n.Span.IntersectsWith(span)); 144declarators = declarations.SelectMany(d => d.Variables.Where(v => v.Span.IntersectsWith(span)));

ExtractMethod\CSharpMethodExtractor.cs (4)

70if (!OriginalSelectionResult.FinalSpan.Contains(anonymousFunction.Span)) 85if (!OriginalSelectionResult.FinalSpan.Contains(localFunction.Span)) 138if (OriginalSelectionResult.FinalSpan.Contains(memberNode.Span)) 159return node.Span.Contains(OriginalSelectionResult.FinalSpan);

ExtractMethod\CSharpSelectionValidator.cs (4)

223if (variable.Initializer != null && variable.Initializer.Span.Contains(span)) 263var expressionBodiedMemberBody = TextSpan.FromBounds(expressionBodiedMember.Expression.SpanStart, expressionBodiedMember.Expression.Span.End); 372if (expression != null && firstStatement.Span.Contains(expression.Span))

ExtractMethod\Extensions.cs (5)

78return constructorInitializer.ContainsInArgument(node.Span); 92return initializer.ArgumentList.Arguments.Any(a => a.Span.Contains(textSpan)); 140return equal.Value != null && equal.Value.Span.Contains(node.Span); 158if (catchClause == null || !textSpan.Contains(catchClause.Span))

GenerateMember\GenerateVariable\CSharpGenerateVariableService.cs (2)

161var startIndex = identifierName.Span.Start - localRoot.Span.Start;

GenerateType\CSharpGenerateTypeService.cs (1)

564? semanticModel.SyntaxTree.GetLocation(new TextSpan(lastMember.Span.End, 0))

InlineHints\CSharpInlineParameterNameHintsService.cs (2)

55buffer.Add((argument.Span.Start, argument, parameter, GetKind(argument.Expression))); 82buffer.Add((argument.Span.Start, argument, parameter, GetKind(argument.Expression)));

IntroduceVariable\CSharpIntroduceVariableService_IntroduceLocal.cs (3)

449var localFunctions = innermostCommonBlock.DescendantNodes().Where(node => node.IsKind(SyntaxKind.LocalFunctionStatement) && matches.Any(match => match.Span.OverlapsWith(node.Span))); 476var earliestLocalFunctionCallIndex = statementsInBlock.IndexOf(s => s.Span.Contains(earliestLocalFunctionCall));

LanguageServices\CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs (1)

244LanguageServices, semanticModel, equalsValue.Value.Span,

NavigationBar\CSharpNavigationBarItemService.cs (3)

274var spanEnd = declaringNode.Span.End; 285spanEnd = fieldDeclaration.Span.End; 312return declaringNode.Span;

QuickInfo\CSharpDiagnosticAnalyzerQuickInfoProvider.cs (2)

86return GetQuickInfoFromSupportedDiagnosticsOfProjectAnalyzers(document, errorCode, errorCodeNode.Span); 124return GetQuickInfoFromSupportedDiagnosticsOfProjectAnalyzers(document, errorCode, suppressMessageCheckIdArgument.Span);

QuickInfo\CSharpSyntacticQuickInfoProvider.cs (2)

146return QuickInfoItem.Create(token.Span, relatedSpans: [regionStart.Span]); 153.Select(d => d.Span)

SignatureHelp\AttributeSignatureHelpProvider.cs (1)

68expression.ArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\ConstructorInitializerSignatureHelpProvider.cs (1)

64expression.ArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\ElementAccessExpressionSignatureHelpProvider.cs (4)

118return TextSpan.FromBounds(conditional.Span.Start, openBracket.FullSpan.End); 288return expression.ArgumentList.Span.Contains(token.SpanStart) && 337return TextSpan.FromBounds(expression.SpanStart, openBracket.Parent.Span.End); 373return expression.ArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\GenericNameSignatureHelpProvider.cs (1)

72node.TypeArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\InitializerExpressionSignatureHelpProvider.cs (1)

53=> expression.Span.Contains(token.SpanStart) && token != expression.CloseBraceToken;

SignatureHelp\InvocationExpressionSignatureHelpProvider.cs (1)

59return expression.ArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\LightweightOverloadResolution.cs (1)

237=> expression.Span.IsEmpty;

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider.cs (1)

57expression.ArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\PrimaryConstructorBaseTypeSignatureHelpProvider.cs (1)

61expression.ArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\TupleConstructionSignatureHelpProvider.cs (3)

71if (!currentSpan.Contains(expression.Span)) 90if (!currentSpan.Contains(expression.Span)) 161return CreateSignatureHelpItems(items, targetExpression.Span, state, selectedItemIndex: null, parameterIndexOverride: -1);

Snippets\CSharpSnippetFunctionService.cs (1)

34var expressionNode = token.GetAncestor(n => n.Span == switchExpressionSpan);

SolutionCrawler\CSharpDocumentDifferenceService.cs (4)

25(constructor.Initializer != null && constructor.Initializer.Span.Contains(span)); 29return property.AccessorList != null && property.AccessorList.Span.Contains(span); 31return @enum.EqualsValue != null && @enum.EqualsValue.Span.Contains(span); 33return field.Declaration != null && field.Declaration.Span.Contains(span);

SplitStringLiteral\InterpolatedStringSplitter.cs (3)

45if (content.Span.End <= CursorPosition) 50else if (content.Span.Start >= CursorPosition) 59afterSplitContents.Insert(0, CreateInterpolatedStringText(CursorPosition, content.Span.End));

SplitStringLiteral\StringSplitter.cs (2)

89if (CursorPosition <= nodeToReplace.SpanStart || CursorPosition >= nodeToReplace.Span.End) 119return (newRoot2, rightExpression.Span.Start + indentString.Length + StringOpenQuoteLength());

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

41if (!context.ShouldAnalyzeSpan(member.Span))

src\Analyzers\CSharp\Analyzers\AddBraces\CSharpAddBracesDiagnosticAnalyzer.cs (2)

132var ifStatementSpanWithoutElse = TextSpan.FromBounds(statement.Span.Start, embeddedStatement.Span.End);

src\Analyzers\CSharp\Analyzers\ConvertNamespace\ConvertToFileScopedNamespaceDiagnosticAnalyzer.cs (1)

57: declaration.SyntaxTree.GetLocation(TextSpan.FromBounds(declaration.SpanStart, declaration.Name.Span.End));

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

151if (!context.ShouldAnalyzeSpan(localDeclaration.Span)) 335var localStatementStart = localStatement.Span.Start; 336var argumentNodeStart = argumentNode.Span.Start; 344var descendentStart = descendentNode.Span.Start;

src\Analyzers\CSharp\Analyzers\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessAnalyzer.cs (4)

136[Location.Create(tree, ifStatement.Span), Location.Create(tree, expressionStatement.Span)], 202if (nextToken.Span.Start < ifStatement.Span.End) 204fadeLocation = Location.Create(tree, TextSpan.FromBounds(nextToken.Span.Start, ifStatement.Span.End));

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryCast\CSharpRemoveUnnecessaryCastDiagnosticAnalyzer.cs (1)

32BinaryExpressionSyntax binary => TextSpan.FromBounds(binary.OperatorToken.SpanStart, node.Span.End),

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

231var endReportSpan = TextSpan.FromBounds(invokedExpression.Span.End, anonymousFunction.Span.End);

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\CSharpRemoveUnnecessaryNullableDirectiveDiagnosticAnalyzer.cs (6)

127|| !possibleNullableImpactIntervalTree.HasIntervalThatOverlapsWith(currentOptionsDirective.Span.End, nullableDirectiveTrivia.SpanStart - currentOptionsDirective.Span.End)) 148possibleNullableImpactIntervalTree.AddIntervalInPlace(directive.Span); 159|| !possibleNullableImpactIntervalTree.HasIntervalThatOverlapsWith(currentOptionsDirective.Span.End, root.Span.End - currentOptionsDirective.Span.End))

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

47if (node.Span.End < _positionOfFirstReducingNullableDirective) 52if (_ignoredSpans.HasIntervalThatContains(node.SpanStart, node.Span.Length)) 135SpansBuilder.Add(predefinedType.Span); 153SpansBuilder.Add(node.Span);

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

221? arrayCreationExpression.Type.Span.End

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

302text.Lines.GetLineFromPosition(expression.SpanStart).LineNumber + 1 == text.Lines.GetLineFromPosition(expression.Span.End).LineNumber &&

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

112expression.Type.Span.End)));

src\Analyzers\CSharp\Analyzers\UseImplicitOrExplicitType\CSharpTypeStyleDiagnosticAnalyzerBase.cs (1)

55context.ReportDiagnostic(CreateDiagnostic(descriptor, declarationStatement, declaredType.StripRefIfNeeded().Span, typeStyle.Notification, context.Options));

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseRangeOperatorDiagnosticAnalyzer.cs (1)

319TextSpan.FromBounds(arguments.First().SpanStart, arguments.Last().Span.End));

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

180if (context.ShouldAnalyzeSpan(localDeclaration.Span)) 184&& context.ShouldAnalyzeSpan(anonymousFunctionStatement!.Span)) 247var descendentStart = descendentNode.Span.Start;

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

160if (forStatement.Condition is null || !forStatement.Condition.Span.Contains(_comparison.Span)) 256if (node.SpanStart < _localStatement.Span.End) 260if (node.Span.End >= _comparison.SpanStart) 354var scopeSpan = scope.Span; 368if (descendentNodeSpanStart >= comparisonSpanStart && scopeSpan.Contains(descendentNode.Span))

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

117if (!syntaxContext.ShouldAnalyzeSpan(localStatement.Span)) 217descendentNode.Span.IntersectsWith(comparisonEnclosingBlock.Span) &&

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

83if (!syntaxContext.ShouldAnalyzeSpan(localDeclarationStatement.Span))

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

123var span = TextSpan.FromBounds(elements[0].Syntax.SpanStart, elements[^1].Syntax.Span.End);

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

97var indentation = sourceText.GetLeadingWhitespaceOfLineAtPosition(node.Span.Start);

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

141foreach (var container in unassignedParameters.Keys.OrderByDescending(n => n.Span.Start))

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

165lastRawStringLiteralData = (stringNode, ComputeCommonIndentationLength(text.Lines.GetLineFromPosition(stringNode.Span.End)));

src\Analyzers\CSharp\CodeFixes\Iterator\CSharpAddYieldCodeFixProvider.cs (2)

107var symbol = model.GetEnclosingSymbol(node.Span.Start, cancellationToken); 220node = ancestors.FirstOrDefault(n => n.Span.Contains(span) && n != root && n.IsKind(SyntaxKind.ReturnStatement));

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

733totalLength += expression.Span.Length; 762totalLength += component.Span.Length;

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

31(node, level) => !node.Span.OverlapsWith(span) || InvalidLevel(level),

StringIndentation\CSharpStringIndentationService.cs (4)

119builder.Add(interpolation.Span); 130if (content is InterpolationSyntax && content.Span.Contains(sourceSpan)) 144var holeEndLine = text.Lines.GetLineFromPosition(interpolation.Span.End).LineNumber; 163var lastLine = text.Lines.GetLineFromPosition(expression.Span.End);

Structure\CSharpStructureHelpers.cs (1)

323node.Span,

Structure\Providers\AnonymousObjectCreationExpressionStructureProvider.cs (2)

38textSpan: TextSpan.FromBounds(node.NewKeyword.Span.End, node.Span.End), 39hintSpan: node.Span,

Structure\Providers\ArgumentListStructureProvider.cs (1)

24node.Span));

Structure\Providers\ArrowExpressionClauseStructureProvider.cs (6)

30hintSpan: TextSpan.FromBounds(parent.Span.Start, end), 55matchingDirectives[0].Span.Start >= parent.Span.Start && 56matchingDirectives.All(d => d.Span.End <= nextToken.Span.Start)) 59return lastDirective.Span.End; 65return parent.Span.End;

Structure\Providers\BlockSyntaxStructureProvider.cs (6)

141textSpan: node.Span, 142hintSpan: node.Span, 162var start = parent.Span.Start; 172return node.Span; 193return node.Span.End; 199return node.GetRequiredParent().Span.End;

Structure\Providers\CollectionExpressionStructureProvider.cs (2)

40: node.Span.End; 61var textSpan = TextSpan.FromBounds(previousToken.Span.End, node.Span.End);

Structure\Providers\InitializerExpressionStructureProvider.cs (3)

42: node.Span.End; 64textSpan: TextSpan.FromBounds(previousToken.Span.End, node.Span.End), 65hintSpan: node.Parent.Span,

Structure\Providers\InterpolatedStringExpressionStructureProvider.cs (2)

29textSpan: node.Span, 30hintSpan: node.Span,

Structure\Providers\RegionDirectiveStructureProvider.cs (2)

19var prefixLength = kw.Span.End - simpleDirective.Span.Start; 54textSpan: TextSpan.FromBounds(regionDirective.SpanStart, match.Span.End),

Structure\Providers\StringLiteralExpressionStructureProvider.cs (3)

29textSpan: node.Span, 30hintSpan: node.Span, 48var span = node.Span;

Structure\Providers\SwitchExpressionStructureProvider.cs (1)

25hintSpan: node.Span,

Structure\Providers\SwitchStatementStructureProvider.cs (4)

24textSpan: TextSpan.FromBounds(node.CloseParenToken != default ? node.CloseParenToken.Span.End : node.Expression.Span.End, node.CloseBraceToken.Span.End), 25hintSpan: node.Span, 33var end = section.Statements.Last().Span.End; 38hintSpan: section.Span,

UseExpressionBody\UseExpressionBodyCodeRefactoringProvider.cs (2)

128declaration.Span); 141declaration.Span);

UsePatternMatching\CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs (3)

171if (node.Span.End >= type.Span.End) 205var diagnostics = updatedSemanticModel.GetDiagnostics(currentNode.Span, cancellationToken);

Wrapping\SeparatedSyntaxList\CSharpCollectionExpressionWrapper.cs (1)

52return listSyntax.Span.Contains(position);

Wrapping\SeparatedSyntaxList\CSharpInitializerExpressionWrapper.cs (1)

52return listSyntax.Span.Contains(position);

EditAndContinue\BreakpointSpansTests.cs (1)

95var endPosition = root.Span.End;

Semantics\FieldInitializerBindingTests.cs (1)

282var initValueLineNumber = syntaxTree.GetLineSpan(initValueSyntax.Span).StartLinePosition.Line;

Semantics\GlobalUsingDirectiveTests.cs (4)

4979Assert.Equal("alias1=C1", model.GetSpeculativeAliasInfo(tree.GetRoot().Span.End, alias1, SpeculativeBindingOption.BindAsExpression).ToTestDisplayString()); 4980Assert.Equal("alias1=C1", model.GetSpeculativeAliasInfo(tree.GetRoot().Span.End, alias1, SpeculativeBindingOption.BindAsTypeOrNamespace).ToTestDisplayString()); 4984Assert.Equal("alias1=C1", model.GetSpeculativeAliasInfo(tree.GetRoot().Span.End, alias1, SpeculativeBindingOption.BindAsExpression).ToTestDisplayString()); 4985Assert.Equal("alias1=C1", model.GetSpeculativeAliasInfo(tree.GetRoot().Span.End, alias1, SpeculativeBindingOption.BindAsTypeOrNamespace).ToTestDisplayString());

Semantics\NullableContextTests.cs (1)

735bool actualAnalysis = tree.IsNullableAnalysisEnabled(methodDeclaration.Span).Value;

Semantics\QueryTests.cs (3)

3424bool success = model.TryGetSpeculativeSemanticModel(methodM.Body.Statements[1].Span.End, queryStatement, out speculativeModel); 3468bool success = model.TryGetSpeculativeSemanticModel(methodM.Body.Statements[1].Span.End, queryStatement, out speculativeModel); 3554bool success = model.TryGetSpeculativeSemanticModel(methodM.Body.Statements[0].Span.End, queryStatement, out speculativeModel);

Semantics\TopLevelStatementsTests.cs (7)

2926model1.GetDiagnostics(nameRef.Ancestors().OfType<StatementSyntax>().First().Span).Verify( 2948model2.GetDiagnostics(nameRef.Ancestors().OfType<StatementSyntax>().First().Span).Verify( 8654for (int i = id.SpanStart; i <= id.Span.End; i++) 8676for (int i = id.SpanStart; i <= id.Span.End; i++) 8698for (int i = id.SpanStart; i <= id.Span.End; i++) 9708model.TryGetSpeculativeSemanticModel(root.DescendantNodes().Single(n => n is ExpressionStatementSyntax { Parent: GlobalStatementSyntax }).Span.End, nodeToSpeculate, out var speculativeModelInTopLevel); 9713model.TryGetSpeculativeSemanticModel(root.DescendantNodes().Single(n => n is ExpressionStatementSyntax { Parent: BlockSyntax }).Span.End, nodeToSpeculate, out var speculativeModelOutsideTopLevel);

Compilation\SemanticModelAPITests.cs (5)

1394var info = model.GetSpeculativeSymbolInfo(oldSyntax.ParameterList.Span.End, newSyntax); 1920bool success = model.TryGetSpeculativeSemanticModel(methodDecl.Body.Statements[0].Span.End, switchStatement, out statModel); 1958bool success = model.TryGetSpeculativeSemanticModel(methodDecl.Body.Statements[0].Span.End, speculatedStatement, out speculativeModel); 2264var success = model.TryGetSpeculativeSemanticModel(methodDecl.Body.Statements[0].Span.End, unsafeStatement, out speculativeModel); 2679var success = model.TryGetSpeculativeSemanticModelForMethodBody(methodDecl.Body.Statements[0].Span.End, speculatedMethod, out speculativeModel);

DeclarationTests.cs (2)

921if (node.Span == nodeInUnderlying.Span && node.RawKind == nodeInUnderlying.RawKind)

Symbols\AnonymousTypesSemanticsTests.cs (6)

1494var pos = data.Nodes[0].Span.End; 1513pos = data.Nodes[3].Span.End; 2010while (current.Span == identifier.Span && !current.IsKind(SyntaxKind.IdentifierName)) 2017var span = node.Span; 2059if (span.Contains(node.Span))

Symbols\AnonymousTypesSymbolTests.cs (2)

1702Assert.True(statement1.Span.Contains(typeA3.Locations[0].SourceSpan)); 1703Assert.True(statement2.Span.Contains(typeA4.Locations[0].SourceSpan));

Symbols\Source\NullablePublicAPITests.cs (1)

4117var position = localFunction.DescendantNodes().OfType<VariableDeclarationSyntax>().Single().Span.End;

Diagnostics\LineSpanDirectiveTests.cs (1)

486var mappedLineAndPositionSpan = unmappedText.GetMappedLineSpanAndVisibility(syntax.Span, out _);

Syntax\LambdaUtilitiesTests.cs (1)

49bool expected = enclosingMethod.MethodKind == MethodKind.LambdaMethod && enclosingSyntax.Span.Contains(span.Value);

Syntax\SyntaxAnnotationTests.cs (2)

624Assert.Equal(oldNode.Span, annotatedNode.Span);

Syntax\SyntaxNodeTests.cs (9)

729Assert.Equal(root, root.FindNode(root.Span, findInsideTrivia: false)); 730Assert.Equal(root, root.FindNode(root.Span, findInsideTrivia: true)); 736var position = identifier.Span.Start + 1; 738Assert.Equal(classDecl, root.FindNode(identifier.Span, findInsideTrivia: false)); 739Assert.Equal(identifier, root.FindNode(identifier.Span, findInsideTrivia: true)); 1781Assert.Equal(rootNode.Span.Length, rootNode.ToString().Length); 1799Assert.Equal(rootNode.Span.Length, rootNode.ToString().Length); 1814Assert.Equal(namespaceNode.Span, nodeOrToken.Span); 2080Assert.Equal(method.Span, nodeLocation.SourceSpan);

Syntax\SyntaxTests.cs (1)

164var span = section.Span;

Classification\SyntaxClassification\DiscardSyntaxClassifier.cs (2)

30result.Add(new ClassifiedSpan(syntax.Span, ClassificationTypeNames.Keyword)); 51result.Add(new ClassifiedSpan(syntax.Span, ClassificationTypeNames.Keyword));

Classification\SyntaxClassification\NameSyntaxClassifier.cs (6)

145classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.NamespaceName); 153classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.Keyword); 160classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.Keyword); 168classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.Keyword); 175classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.Keyword); 328result.Add(new(name.Span, ClassificationTypeNames.Keyword));

Classification\SyntaxClassification\UsingDirectiveSyntaxClassifier.cs (2)

52result.Add(new ClassifiedSpan(token.Span, classification)); 57result.Add(new ClassifiedSpan(token.Span, ClassificationTypeNames.NamespaceName));

Classification\Worker.cs (1)

262if (!_textSpan.OverlapsWith(skippedTokens.Span))

Classification\Worker_DocumentationComments.cs (1)

16if (!_textSpan.OverlapsWith(documentationComment.Span))

Classification\Worker_Preprocesser.cs (1)

15if (!_textSpan.OverlapsWith(node.Span))

CodeGeneration\CSharpSyntaxGenerator.cs (8)

2885if (root.Span.Contains(declaration.Span)) 3024if (root.Span.Contains(declaration.Span)) 3063if (root.Span.Contains(declaration.Span)) 3133if (root.Span.Contains(node.Span))

Rename\CSharpRenameRewriterLanguageService.cs (4)

162if (_conflictLocations.Any(cf => cf.Contains(lambda.Span))) 195_conflictLocations.Contains(node.Span) && 294var oldSpan = originalNode.Span; 309var newSpan = newNode.Span;

Simplification\Reducers\CSharpNullableAnnotationReducer.cs (1)

37var context = semanticModel.GetNullableContext(node.Span.End);

Simplification\Simplifiers\ExpressionSimplifier.cs (7)

50issueSpan = memberAccessExpression.Expression.Span; 108issueSpan = memberAccess.Span; 163issueSpan = memberAccess.Span; 169issueSpan = memberAccess.Expression.Span; 189issueSpan = memberAccess.Span; // we want to show the whole expression as unnecessary 215issueSpan = memberAccess.Expression.Span; 436issueSpan = left.Span;

Simplification\Simplifiers\NameSimplifier.cs (9)

92issueSpan = genericName.TypeArgumentList.Span; 108issueSpan = name.Span; 166issueSpan = name.Span; 176issueSpan = qualifiedName3.Left.Span; 296issueSpan = name.Span; 322issueSpan = ((AliasQualifiedNameSyntax)name).Alias.Span; 328issueSpan = ((QualifiedNameSyntax)name).Left.Span; 455return !name.Span.Contains(argumentDecl.Span); 472issueSpan = name.Span; // we want to show the whole name expression as unnecessary

Simplification\Simplifiers\QualifiedCrefSimplifier.cs (2)

58issueSpan = crefSyntax.Span; 96issueSpan = crefSyntax.Container.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\EmbeddedLanguages\VirtualChars\CSharpVirtualCharService.cs (1)

188var indentationLength = parentSourceText.Lines.GetLineFromPosition(parentExpression.Span.End).GetFirstNonWhitespaceOffset() ?? 0;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\BlockSyntaxExtensions.cs (3)

73conditionalDirectives.Last().Span.End >= block.CloseBraceToken.Span.End) 79if (conditionalDirectives.Last().Span.End <= statement.Span.Start)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs (1)

561var matchSpan = match.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\CSharpTriviaFormatter.DocumentationCommentExteriorCommentRewriter.cs (1)

75trivia.Span.End == currentParent.Span.End)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (2)

711if (useFullSpan || node.Span.Contains(position)) 919if (node.Span.IsEmpty)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\CompilationUnitSyntaxExtensions.cs (3)

43var end = usings.Last().Span.End; 52var end = rootUsings.Last().Span.End; 60: root.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\CSharpSyntaxContext.cs (1)

503lockStatement.Statement.Span.Contains(position))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\SyntaxTreeExtensions.cs (1)

683return declaration?.Name.Span.IntersectsWith(position) == true;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\TypeDeclarationSyntaxExtensions.cs (1)

46start = members.Last().Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpRemoveUnnecessaryImportsService.cs (1)

67spansToFormat.Add(TextSpan.FromBounds(baseNamespace.Name.Span.End, firstMemberB.SpanStart));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)

2217if (descendant.SpanStart <= afterNode.Span.End)

Workspace\LanguageServices\CSharpSyntaxTreeFactoryService.NodeSyntaxReference.cs (1)

25=> _node.Span;

InlineRename\AbstractEditorInlineRenameService.cs (1)

60return targetNode.Span;

Peek\PeekHelpers.cs (1)

70return identifierLocation.SourceTree.GetLocation(node.Span).GetMappedLineSpan().Span;

TextStructureNavigation\AbstractTextStructureNavigatorProvider.TextStructureNavigator.cs (1)

328while (node.Parent != null && node.Parent.Span == node.Span)

RefactoringHelpers\RefactoringHelpersTestBase.cs (2)

38Assert.Equal(result, resultNode!.Span); 56Assert.Equal(result, resultNode!.Span);

Structure\AbstractSyntaxNodeStructureProviderTests.cs (2)

33(position == node.Span.End && position == node.Parent.Span.End))

CodeFixes\CodeFixServiceTests.cs (4)

1022? root.DescendantNodes().OfType<CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax>().First().Span 1023: root.DescendantNodes().OfType<CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax>().First().Span; 1058? root.DescendantNodes().OfType<CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax>().First().Span 1059: root.DescendantNodes().OfType<CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax>().First().Span;

CodeGeneration\CodeGenerationTests.cs (1)

937return token.Parent.AncestorsAndSelf().OfType<T>().FirstOrDefault(t => !fullSpanCoverage || t.Span.End >= destSpan.End);

Diagnostics\DiagnosticAnalyzerServiceTests.cs (1)

688: localDeclaration.Span;

InheritanceMargin\InheritanceMarginTests.cs (1)

106var searchingSpan = root.Span;

Expansion\AbstractExpansionTest.vb (1)

60If node.Span.End = spanEnd Then

Simplification\AbstractSimplificationTests.vb (1)

134If node.Span.End = spanEnd Then

Internal\Analyzer\CSharp\CSharpCopilotCodeAnalysisService.cs (1)

131if (containingMethod?.Span.IntersectsWith(span) is true)

AddImport\AbstractAddImportFeatureService.cs (1)

95.GetAncestor(n => n.Span.Contains(span) && n != root);

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (2)

309var containedDecls = decls.Where(d => span.Contains(d.DeclaredNode.Span)); 322var declSpan = decl.DeclaredNode.Span;

CodeLens\CodeLensFindReferenceProgress.cs (2)

79where !(_queriedNode.Span == candidateSyntaxNode.Span &&

CodeRefactorings\AddAwait\AbstractAddAwaitCodeRefactoringProvider.cs (2)

57expression.Span); 65expression.Span);

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (3)

290spanForContainers.Add(container.Span); 911return x.Span.Start - y.Span.Start;

Completion\Providers\AbstractPartialTypeCompletionProvider.cs (1)

107.Any(node => !(node.SyntaxTree == context.SyntaxTree && node.Span.IntersectsWith(context.Position)));

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (2)

68anonymousObject.Span); 76anonymousObject.Span);

ConvertAutoPropertyToFullProperty\AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (2)

54property.Span); 65property.Span);

ConvertCast\AbstractConvertCastCodeRefactoringProvider.cs (1)

64from.Span);

ConvertForEachToFor\AbstractConvertForEachToForCodeRefactoringProvider.cs (1)

82foreachStatement.Span);

ConvertForToForEach\AbstractConvertForToForEachCodeRefactoringProvider.cs (1)

141forStatement.Span);

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.cs (3)

57ifStatement.Span); 67ifStatement.Span); 241if (!fixAllSpans.Any(fixAllSpan => fixAllSpan.Contains(originalIfStatement.Span)))

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.Rewriting.cs (1)

38var ifSpan = ifStatement.Span;

ConvertLinq\AbstractConvertLinqQueryToForEachProvider.cs (1)

51queryExpression.Span);

ConvertLinq\ConvertForEachToLinqQuery\AbstractConvertForEachToLinqQueryProvider.cs (3)

93if (semanticModel.GetDiagnostics(forEachStatement.Span, cancellationToken) 118forEachStatement.Span); 141forEachStatement.Span);

ConvertToInterpolatedString\AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs (1)

114top.Span);

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (2)

138invocation.Span); 289if (normalizedSpans.IntersectsWith(childNode!.Span))

ConvertToInterpolatedString\ConvertRegularStringToInterpolatedStringRefactoringProvider.cs (1)

80literalExpression.Span);

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (2)

101tupleExprOrTypeNode.Span); 113tupleExprOrTypeNode.Span);

Debugging\AbstractDataTipInfoGetter.cs (1)

37return (DebugDataTipInfoKind.LinqExpression, invocation.Span);

Diagnostics\Analyzers\UnboundIdentifiersDiagnosticAnalyzerBase.cs (1)

68var typeNames = member.DescendantNodes().Where(n => IsQualifiedOrSimpleName(n) && !n.Span.IsEmpty);

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (10)

261=> TryGetDiagnosticSpan(node, editKind) ?? node.Span; 270return node.Span; 1424if (!newEncompassingAncestor.Span.Contains(newStatementSyntaxSpan.Start)) 1700if (TryGetActiveSpan(statement, statementPart, minLength: statement.Span.Length, out var span)) 1711return node.Span; 1722return statement.Span; 2355triviaEdits.Add((segment.oldNode, segment.newNode, segment.newNode.Span)); 5038locationNode.Span : analyzer.GetDiagnosticSpan(GetDiagnosticNode(out var distance, cancellationToken), distance > 0 ? EditKind.Delete : EditKind.Update), 5266if (!TryFindMemberDeclaration(root: null, newNode, newNode.Span, out var newDeclarations)) 5302if (!TryFindMemberDeclaration(root: null, newNode, newNode.Span, out var newDeclarations))

EditAndContinue\AbstractSimpleMemberBody.cs (1)

26=> node.Span;

EncapsulateField\AbstractEncapsulateFieldService.cs (1)

313.Select(n => (solution.GetRequiredDocument(n.SyntaxTree).Id, n.Span))

ExtractMethod\MethodExtractor.Analyzer.cs (1)

434var analysisRange = TextSpan.FromBounds(SelectionResult.FinalSpan.Start, containingScope.Span.End);

ExtractMethod\SelectionInfo.cs (2)

106if (firstStatement.Span.Contains(lastStatement.Span))

ExtractMethod\SelectionResult.cs (1)

150if (childNode.Span.OverlapsWith(span))

ExtractMethod\SelectionValidator.cs (3)

84if (firstStatement != null && statement.Span.End <= textSpan.End && statement.Parent == firstStatement.Parent) 159if (statement.Span.End < textSpan.Start) 173if (textSpan.End <= statement.Span.End && spine.Any(s => AreStatementsInSameContainer(s, statement)))

FullyQualify\AbstractFullyQualifyService.cs (1)

68var node = root.FindToken(span.Start).GetAncestors<SyntaxNode>().First(n => n.Span.Contains(span));

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.cs (1)

262pickMemberOptions.ToImmutable()), typeDeclaration.Span);

GenerateOverrides\GenerateOverridesCodeRefactoringProvider.cs (1)

58typeDeclaration.Span);

GenerateType\AbstractGenerateTypeService.Editor.cs (1)

394new CodeGenerationContext(afterThisLocation: _semanticDocument.SyntaxTree.GetLocation(_state.SimpleName.Span))),

InitializeParameter\AbstractInitializeParameterCodeRefactoringProvider.cs (1)

122listOfPotentiallyValidParametersNodes.ToImmutable(), selectedParameter.Span, cancellationToken).ConfigureAwait(false);

InlineHints\AbstractInlineParameterNameHintsService.cs (1)

65foreach (var node in root.DescendantNodes(textSpan, n => n.Span.IntersectsWith(textSpan)))

InlineHints\AbstractInlineTypeHintsService.cs (1)

56foreach (var node in root.DescendantNodes(n => n.Span.IntersectsWith(textSpan)))

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (1)

242context.RegisterRefactoring(nestedCodeAction, calleeInvocationNode.Span);

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (2)

83localDeclaration.Span); 97expressionStatement.Span);

IntroduceVariable\AbstractIntroduceLocalForExpressionCodeRefactoringProvider.cs (2)

59expressionStatement.Span); 67expressionStatement.Span);

InvertConditional\AbstractInvertConditionalCodeRefactoringProvider.cs (1)

36conditional.Span);

InvertIf\AbstractInvertIfCodeRefactoringProvider.cs (1)

100ifNode.Span);

InvertLogical\AbstractInvertLogicalCodeRefactoringProvider.cs (1)

79expression.Span);

MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceCodeRefactoringProvider.cs (1)

43declaration.Span);

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

37argument.Span);

ReplaceConditionalWithStatements\AbstractReplaceConditionalWithStatementsCodeRefactoringProvider.cs (2)

137conditionalExpression.Span); 166conditionalExpression.Span);

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (2)

73methodDeclaration.Span); 86methodDeclaration.Span);

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (1)

68propertyDeclaration.Span);

SimplifyTypeNames\AbstractSimplifyTypeNamesCodeFixProvider.cs (1)

58if (node.Span.IntersectsWith(span) && CanSimplifyTypeNameExpression(model, node, options, span, out var diagnosticId, cancellationToken))

Snippets\SnippetFunctionService.cs (1)

146var nodeToReplace = syntaxRoot.DescendantNodes().FirstOrDefault(n => n.Span == fullyQualifiedTypeSpan);

Snippets\SnippetProviders\AbstractConsoleSnippetProvider.cs (1)

67return caretTarget.Span.End;

SolutionCrawler\AbstractDocumentDifferenceService.cs (4)

164if (oldMember.Span.IsEmpty) 170if (!oldMember.Span.Contains(range.Span)) 178return (oldMember.Span.Length + lengthDelta) == newMember.Span.Length ? newMember : null;

SpellCheck\AbstractSpellCheckCodeFixProvider.cs (1)

48if (node != null && node.Span == span)

SplitOrMergeIfStatements\AbstractMergeIfStatementsCodeRefactoringProvider.cs (5)

47RegisterRefactoring(MergeDirection.Up, upperIfOrElseIf.Span, ifOrElseIf.Span); 50RegisterRefactoring(MergeDirection.Down, ifOrElseIf.Span, lowerIfOrElseIf.Span); 83node => ifGenerator.IsIfOrElseIf(node) && node.Span == span);

SplitOrMergeIfStatements\AbstractSplitIfStatementCodeRefactoringProvider.cs (2)

54c => RefactorAsync(document, token.Span, ifOrElseIf.Span, c), 56ifOrElseIf.Span);

src\Analyzers\Core\Analyzers\PopulateSwitch\AbstractPopulateSwitchDiagnosticAnalyzer.cs (1)

66if (switchBlock.SyntaxTree.OverlapsHiddenPosition(switchBlock.Span, context.CancellationToken))

src\Analyzers\Core\Analyzers\RemoveUnnecessaryCast\AbstractRemoveUnnecessaryCastDiagnosticAnalyzer.cs (1)

66if (tree.OverlapsHiddenPosition(node.Span, cancellationToken))

src\Analyzers\Core\Analyzers\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (3)

153textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 167textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 181var end = node.Span.End;

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (1)

129if (memberDecl != null && !context.ShouldAnalyzeSpan(memberDecl.Span))

src\Analyzers\Core\Analyzers\SimplifyInterpolation\AbstractSimplifyInterpolationHelpers.cs (3)

109unnecessarySpans.AddRange(invocation.Syntax.Span 124unnecessarySpans.AddRange(invocation.Syntax.Span 234unnecessarySpans.AddRange(invocation.Syntax.Span

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (1)

205if (node is TPropertyDeclaration or TFieldDeclaration && context.ShouldAnalyzeSpan(node.Span, node.SyntaxTree))

src\Analyzers\Core\Analyzers\UseCollectionInitializer\UseCollectionInitializerHelpers.cs (2)

37syntaxTree.GetLocation(TextSpan.FromBounds(arguments.Last().FullSpan.End, match.Span.End))); 49syntaxTree.GetLocation(TextSpan.FromBounds(expression.FullSpan.End, match.Span.End)));

src\Analyzers\Core\Analyzers\UseObjectInitializer\AbstractUseObjectInitializerDiagnosticAnalyzer.cs (3)

150: syntaxFacts.GetExpressionOfMemberAccessExpression(match.MemberAccessExpression)!.Span.End; 156if (match.Statement.Span.End > match.Initializer.FullSpan.End) 158locations.Add(syntaxTree.GetLocation(TextSpan.FromBounds(match.Initializer.FullSpan.End, match.Statement.Span.End)));

src\Analyzers\Core\CodeFixes\AddAnonymousTypeMemberName\AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs (1)

58if (node?.Span != span)

src\Analyzers\Core\CodeFixes\AddExplicitCast\Fixer.cs (1)

211if (newRoot.FindNode(targetNode.Span).GetAncestorOrThis<TArgumentListSyntax>() is TArgumentListSyntax newArgumentList)

src\Analyzers\Core\CodeFixes\ConvertToAsync\AbstractConvertToAsyncCodeFixProvider.cs (1)

47node = ancestors.FirstOrDefault(n => n.Span.Contains(span) && n != root);

src\Analyzers\Core\CodeFixes\Iterator\AbstractIteratorCodeFixProvider.cs (1)

44node = ancestors.FirstOrDefault(n => n.Span.Contains(span) && n != root);

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

846var spansToFormat = originalDeclStatementsToMoveOrRemove.Select(s => s.Span);

src\Analyzers\Core\CodeFixes\UseConditionalExpression\AbstractUseConditionalExpressionCodeFixProvider.cs (3)

156if (condition.Span.Length + trueSyntax.Span.Length + falseSyntax.Span.Length > formattingOptions.ConditionalExpressionWrappingLength)

Testing\AbstractTestMethodFinder.cs (3)

40var intersectingNodes = testNodes.WhereAsArray(node => node.Span.IntersectsWith(textSpan)); 47return testNodes.WhereAsArray(node => node.Parent?.Span.IntersectsWith(textSpan) == true); 110return node.Span.IntersectsWith(textSpan) && DescendIntoChildren(node);

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (3)

185fieldDocument.Id == documentId ? !span.IntersectsWith(declarator.Span) : true && // The span check only makes sense if we are in the same file 401.Select(d => (d.SyntaxTree.FilePath, d.Span)) 434if (constructorSpans.Contains((node.SyntaxTree.FilePath, node.Span)))

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (3)

115argument.Span); 122argument.Span); 131argument.Span);

Wrapping\AbstractCodeActionComputer.cs (1)

268return (root, rewrittenRoot, trackedNode.Span);

Wrapping\BinaryExpression\BinaryExpressionCodeActionComputer.cs (1)

62OriginalSourceText.GetOffset(binaryExpression.Span.Start)

Wrapping\SeparatedSyntaxList\AbstractSeparatedSyntaxListWrapper.cs (1)

56if (listSyntax == null || listSyntax.Span.IsEmpty)

Wrapping\SeparatedSyntaxList\SeparatedSyntaxListCodeActionComputer.cs (2)

314currentOffset += item.Span.Length; 331currentOffset = indentationTrivia.FullWidth() + item.Span.Length;

EditAndContinue\EditAndContinueTestVerifier.cs (2)

418if (result.Span == span) 539.ThenByDescending(partners => partners.Key.Span.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationHelpers.cs (1)

221var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= info.Context.BeforeThisLocation.SourceSpan.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (6)

48if (selection.IsEmpty || node.Span.IsEmpty) 54if (selection.Contains(node.Span)) 81var beginningNode = node.FindToken(node.Span.Start).Parent; 82var endNode = node.FindToken(node.Span.End - 1).Parent; 93return beginningNode.Span.End <= selection.Start || endNode.Span.Start >= selection.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

172var affectedSpan = TextSpan.FromBounds(previousToken.SpanStart, FirstStatementAffectedInInnermostBlock.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsService.cs (3)

44=> x?.Span == y?.Span; 47=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

71return !semanticModel.SyntaxTree.OverlapsHiddenPosition(memberAccessExpression.Span, cancellationToken) &&

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NullableHelpers.cs (3)

43semanticFacts, semanticModel, rootOperation, declaredSymbol, rootOperation.Syntax.Span, includeDeclaration: true, cancellationToken) == true; 67if (!span.IntersectsWith(operation.Syntax.Span)) 70if (span.Contains(operation.Syntax.Span) &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

Compilation\ControlFlowGraphVerifier.cs (1)

350if (model.GetDiagnostics(graph.OriginalOperation.Syntax.Span).

Analysis\FlowAnalysis\AlwaysAssignedWalker.vb (3)

76If IsInsideRegion(branch.Branch.Syntax.Span) AndAlso Not _labelsInside.Contains(branch.Label) Then 85If node.Syntax IsNot Nothing AndAlso IsInsideRegion(node.Syntax.Span) Then 93If IsInside AndAlso pending.Branch IsNot Nothing AndAlso Not IsInsideRegion(pending.Branch.Syntax.Span) Then

Analysis\FlowAnalysis\DataFlowsInWalker.vb (3)

68If stmt.Syntax IsNot Nothing AndAlso labelStmt.Syntax IsNot Nothing AndAlso Not IsInsideRegion(stmt.Syntax.Span) AndAlso IsInsideRegion(labelStmt.Syntax.Span) Then 115If IsInsideRegion(node.Span) Then

Analysis\FlowAnalysis\EntryPointsWalker.vb (2)

48If stmt.Syntax IsNot Nothing AndAlso labelStmt.Syntax IsNot Nothing AndAlso IsInsideRegion(labelStmt.Syntax.Span) AndAlso Not IsInsideRegion(stmt.Syntax.Span) Then

Analysis\FlowAnalysis\ExitPointsWalker.vb (1)

103If IsInsideRegion(pending.Branch.Syntax.Span) Then

Analysis\FlowAnalysis\ReadWriteWalker.vb (7)

110If (Me._regionPlace <> RegionPlace.Inside AndAlso fieldAccess.Syntax.Span.Contains(_region)) Then NoteReceiverRead(fieldAccess) 135If _region.Contains(receiverSyntax.Span) Then readOrWritten.Add(CType(receiver, BoundLocal).LocalSymbol) 137If _region.Contains(receiverSyntax.Span) Then readOrWritten.Add(Me.MeParameter) 139If _region.Contains(receiverSyntax.Span) Then readOrWritten.Add(Me.MeParameter) 141If _region.Contains(receiverSyntax.Span) Then readOrWritten.Add(CType(receiver, BoundParameter).ParameterSymbol) 143If _region.Contains(receiverSyntax.Span) Then readOrWritten.Add(CType(receiver, BoundRangeVariable).RangeVariable) 145If receiver.Type.IsStructureType AndAlso receiverSyntax.Span.OverlapsWith(_region) Then NoteReceiverReadOrWritten(CType(receiver, BoundFieldAccess), readOrWritten)

Analysis\FlowAnalysis\VariablesDeclaredWalker.vb (1)

84If IsInsideRegion(catchBlock.Syntax.Span) Then

Binding\Binder_Invocation.vb (5)

1300If node.SyntaxTree Is groupOpt.Syntax.SyntaxTree AndAlso node.Span.Contains(groupOpt.Syntax.Span) Then 1949If argument.Syntax.Span.Contains(diagnostic.Location.SourceSpan) Then 3152callerInfoValue = ConstantValue.Create(callerInfoOpt.SyntaxTree.GetDisplayPath(callerInfoOpt.Span, Me.Compilation.Options.SourceReferenceResolver)) 3289Return syntax.Span

Binding\Binder_Query.vb (4)

624source.Syntax.Span, 4354source.Syntax.Span, additionalDiagnostics) 4372source.Syntax.Span, additionalDiagnostics) 4395source.Syntax.Span, additionalDiagnostics)

CodeGen\CodeGenerator.vb (1)

295EmitSequencePoint(syntax.SyntaxTree, syntax.Span)

Compilation\SyntaxTreeSemanticModel.vb (1)

868If location.SourceTree Is Me.SyntaxTree AndAlso nodeToCheck.Span.Contains(location.SourceSpan) Then

Lowering\Instrumentation\CodeCoverageInstrumenter.vb (2)

543Return syntax.Span 547Dim originalSpan As Text.TextSpan = syntax.Span

Lowering\Instrumentation\DebugInfoInjector.vb (1)

138sequencePointSpan = TextSpan.FromBounds(original.Syntax.SpanStart, original.Syntax.Span.End)

Symbols\LexicalSortKey.vb (2)

214Return first.Span.Start - second.Span.Start

Syntax\SimpleSyntaxReference.vb (1)

31Return _node.Span

Syntax\SyntaxFacts.vb (1)

202Dim span = node.Span

Syntax\SyntaxNodeRemover.vb (3)

214Me.AddDirectives(node, GetRemovedSpan(node.Span, node.FullSpan)) 240Dim span = TextSpan.FromBounds(token.Span.Start, node.Span.End) 264Dim span = TextSpan.FromBounds(node.Span.Start, token.Span.End)

Syntax\VisualBasicSyntaxNode.vb (3)

142''' Same as accessing <see cref="TextSpan.Start"/> on <see cref="Span"/>. 441Return New EmbeddedTreeLocation(tree.GetEmbeddedKind, Me.Span) 443Return New MyTemplateLocation(tree, Me.Span)

src\Analyzers\VisualBasic\Analyzers\AddAccessibilityModifiers\VisualBasicAddAccessibilityModifiersDiagnosticAnalyzer.vb (1)

43If Not context.ShouldAnalyzeSpan(member.Span) Then

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ParenthesizedExpressionSyntaxExtensions.vb (1)

142node.OpenParenToken.Span.End = expression.Span.Start Then

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxNodeExtensions.vb (5)

410Dim parentSpan = trivia.GetStructure().Span 415Dim matchSpan = match.Span 866If declaration.Initializer IsNot Nothing AndAlso declaration.Initializer.Span.Contains(span) Then 873If [property] IsNot Nothing AndAlso [property].Initializer IsNot Nothing AndAlso [property].Initializer.Span.Contains(span) Then 886Dim blockSpan = TextSpan.FromBounds(block.BlockStatement.Span.End, block.EndBlockStatement.SpanStart)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SyntaxFacts\VisualBasicSyntaxFacts.vb (1)

755If useFullSpan OrElse node.Span.Contains(position) Then

src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\GenerateParameterizedMemberCodeFixProvider.vb (2)

62If node.Span.Start = diagnosticSpan.Start AndAlso node.Span.End < diagnosticSpan.End Then

src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicGenerateConversionService.vb (5)

33Return node.AncestorsAndSelf.Where(AddressOf IsCastExpression).Where(Function(n) n.Span.Contains(node.Span)).Any 44Return node.AncestorsAndSelf.Where(Function(n) n.IsKind(SyntaxKind.ImplementsClause)).Where(Function(n) n.Span.Contains(node.Span)).Any 48Return node.AncestorsAndSelf.Where(Function(n) n.IsKind(SyntaxKind.SimpleMemberAccessExpression)).Where(Function(n) n.Span.Contains(node.Span)).Any 84Dim castExpression = TryCast(expression.AncestorsAndSelf.Where(AddressOf IsCastExpression).Where(Function(n) n.Span.Contains(expression.Span)).FirstOrDefault, CastExpressionSyntax) 95expression = TryCast(expression.AncestorsAndSelf.Where(Function(n) TypeOf n Is ExpressionSyntax And n.Span.Contains(expression.Span)).FirstOrDefault, ExpressionSyntax)

src\Analyzers\VisualBasic\CodeFixes\Iterator\VisualBasicConvertToIteratorCodeFixProvider.vb (1)

62Dim symbol = model.GetEnclosingSymbol(node.Span.Start, cancellationToken)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\VisualBasicCodeGenerationService.vb (1)

85TextSpan.FromBounds(destination.Members.Last.Span.End, destination.EndOfFileToken.SpanStart), cancellationToken))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\TypeBlockSyntaxExtensions.vb (1)

19Dim start = destination.BlockStatement.Span.End

EndConstructGeneration\EndConstructStatementVisitor_IfStatement.vb (1)

48Dim position = If(ifBlock.Statements.Any(), ifBlock.Statements(0).SpanStart, ifBlock.IfStatement.Span.End + _state.NewLineCharacter.Length)

EndConstructGeneration\VisualBasicEndConstructGenerationService.vb (1)

311Dim aligningWhitespace = subjectBuffer.CurrentSnapshot.GetAligningWhitespace(state.TokenToLeft.Parent.Span.Start)

LineCommit\CommitBufferManager.vb (1)

207finalSpanEnd = Math.Max(finalSpanEnd, endingStatementInfo.MatchingBlockConstruct.Span.End)

LineCommit\ContainingStatementInfo.vb (3)

17Me.New(node, node.Span) 186Return New ContainingStatementInfo(node, TextSpan.FromBounds(attributes.Last.Span.End, node.Span.End))

Utilities\NavigationPointHelpers.vb (2)

17line = text.Lines.GetLineFromPosition(eventBlock.EventStatement.Span.End).LineNumber + 1 28line = text.Lines.GetLineFromPosition(methodBlock.BlockStatement.Span.End).LineNumber + 1

ChangeSignature\VisualBasicChangeSignatureService.vb (1)

110If Not matchingNode.Span.IntersectsWith(position) Then

CodeFixes\CorrectNextControlVariable\CorrectNextControlVariableCodeFixProvider.vb (1)

51Dim indexOfControlVariable = nextStatement.ControlVariables.IndexOf(Function(n) n.Span.Contains(context.Span))

CodeFixes\GenerateEndConstruct\GenerateEndConstructCodeFixProvider.vb (2)

124Return begin.Span.Contains(node.Span)

CodeFixes\MoveToTopOfFile\MoveToTopOfFileCodeFixProvider.vb (1)

98node.Span.End > m.SpanStart)

CodeFixes\OverloadBase\OverloadBaseCodeFixProvider.AddKeywordAction.vb (1)

74newNode = Await cleanupService.CleanupAsync(newNode, ImmutableArray.Create(newNode.Span), options, services, cleanupService.GetDefaultProviders(), cancellationToken).ConfigureAwait(False)

CodeRefactorings\InlineTemporary\VisualBasicInlineTemporaryCodeRefactoringProvider.vb (1)

65variableDeclarator.Span)

Debugging\DataTipInfoGetter.vb (1)

60Dim span = expression.Span

EditAndContinue\BreakpointSpans.vb (8)

92Return TextSpan.FromBounds(node.SpanStart, node.Span.End) 100Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End) 237Return TextSpan.FromBounds(methodBase.DeclarationKeyword.SpanStart, methodBase.Span.End) 240Return TextSpan.FromBounds(methodBase.Modifiers.First().SpanStart, methodBase.Span.End) 250Return TextSpan.FromBounds(node.Identifier.Span.Start, node.Initializer.Span.End) 254Return TextSpan.FromBounds(node.Identifier.Span.Start, node.AsClause.Span.End) 417Return TextSpan.FromBounds(clause.Keys.First.SpanStart, clause.Span.End) 429Return clause.Variables(GetItemIndexByPosition(clause.Variables, position)).Expression.Span

EditAndContinue\DeclarationBody\FieldOrPropertyDeclarationBody.vb (1)

123Return InitializerActiveStatement.Span

EditAndContinue\DeclarationBody\FieldWithMultipleAsNewClauseDeclarationBody.vb (4)

42Return TextSpan.FromBounds(_modifedIdentifier.Span.Start, NewExpression.Span.End) 48Return TextSpan.FromBounds(_modifedIdentifier.Span.End, NewExpression.Span.Start).Contains(span)

EditAndContinue\DeclarationBody\PropertyWithInitializerDeclarationBody.vb (1)

36Return TextSpan.FromBounds(PropertyStatement.Identifier.Span.Start, PropertyStatement.Initializer.Span.End)

EditAndContinue\DeclarationBody\PropertyWithNewClauseDeclarationBody.vb (1)

42Return TextSpan.FromBounds(PropertyStatement.Identifier.Span.Start, PropertyStatement.AsClause.Span.End)

EditAndContinue\VisualBasicEditAndContinueAnalyzer.vb (27)

EncapsulateField\VisualBasicEncapsulateFieldService.vb (1)

75Dim fields = root.DescendantNodes(Function(n) n.Span.IntersectsWith(span)) _

ExtractMethod\Extensions.vb (9)

74Dim firstContainingSpan = initialNode.Span 85Loop While node IsNot Nothing AndAlso node.Span.Equals(firstContainingSpan) 113Return equal.Value IsNot Nothing AndAlso equal.Value.Span.Contains(node.Span) 121If argument Is Nothing OrElse node.Span <> argument.Span Then 189If Not textSpan.Contains(directive.Span) Then 273If range.UpperBound.Span.Contains(token.Span) AndAlso 283Dim span = TextSpan.FromBounds(asNewClause.NewExpression.NewKeyword.Span.End, asNewClause.NewExpression.Span.End) 320Dim blockSpan = TextSpan.FromBounds(block.BlockStatement.Span.End, block.EndBlockStatement.SpanStart)

GenerateType\VisualBasicGenerateTypeService.vb (2)

392simpleName.Span.End <= t.Members.Last().Span.End) 445semanticModel.SyntaxTree.GetLocation(New TextSpan(lastMember.Span.End, 0)))

Highlighting\KeywordHighlighters\MultiLineIfBlockHighlighter.vb (1)

51highlights.Add(ifBlock.EndIfStatement.Span)

Highlighting\KeywordHighlighters\TryBlockHighlighter.vb (1)

59highlights.Add(node.Span)

Highlighting\KeywordHighlightingHelpers.vb (2)

22highlights.Add(.Span) 28highlights.Add(.Span)

InlineHints\VisualBasicInlineParameterNameHintsService.vb (1)

55buffer.Add((argument.Span.Start, argument, parameter, GetKind(argument.Expression)))

LanguageServices\VisualBasicSymbolDisplayService.SymbolDescriptionBuilder.vb (1)

160LanguageServices, semanticModel, equalsValue.Value.Span, Options.ClassificationOptions, CancellationToken).ConfigureAwait(False)

SignatureHelp\AttributeSignatureHelpProvider.vb (1)

47node.ArgumentList.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\CastExpressionSignatureHelpProvider.vb (1)

47Return node.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\CollectionInitializerSignatureHelpProvider.vb (1)

42Return expression.Span.Contains(token.SpanStart) AndAlso token <> expression.CloseBraceToken

SignatureHelp\ConditionalExpressionSignatureHelpProvider.vb (1)

33Return node.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\GenericNameSignatureHelpProvider.vb (1)

56Return node.TypeArgumentList.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\InvocationExpressionSignatureHelpProvider.vb (1)

58node.ArgumentList.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\MidAssignmentSignatureHelpProvider.vb (1)

40DirectCast(node.Left, MidExpressionSyntax).ArgumentList.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider.vb (1)

57node.ArgumentList.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\RaiseEventStatementSignatureHelpProvider.vb (1)

56statement.ArgumentList.Span.Contains(token.SpanStart) AndAlso

SolutionCrawler\VisualBasicDocumentDifferenceService.vb (4)

44Return [enum].Initializer IsNot Nothing AndAlso ContainsExclusively([enum].Initializer.Span, span) 49Return propStatement.Initializer IsNot Nothing AndAlso ContainsExclusively(propStatement.Initializer.Span, span) 65Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End) 70Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End)

src\Analyzers\VisualBasic\Analyzers\AddAccessibilityModifiers\VisualBasicAddAccessibilityModifiersDiagnosticAnalyzer.vb (1)

43If Not context.ShouldAnalyzeSpan(member.Span) Then

src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\GenerateParameterizedMemberCodeFixProvider.vb (2)

62If node.Span.Start = diagnosticSpan.Start AndAlso node.Span.End < diagnosticSpan.End Then

src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicGenerateConversionService.vb (5)

33Return node.AncestorsAndSelf.Where(AddressOf IsCastExpression).Where(Function(n) n.Span.Contains(node.Span)).Any 44Return node.AncestorsAndSelf.Where(Function(n) n.IsKind(SyntaxKind.ImplementsClause)).Where(Function(n) n.Span.Contains(node.Span)).Any 48Return node.AncestorsAndSelf.Where(Function(n) n.IsKind(SyntaxKind.SimpleMemberAccessExpression)).Where(Function(n) n.Span.Contains(node.Span)).Any 84Dim castExpression = TryCast(expression.AncestorsAndSelf.Where(AddressOf IsCastExpression).Where(Function(n) n.Span.Contains(expression.Span)).FirstOrDefault, CastExpressionSyntax) 95expression = TryCast(expression.AncestorsAndSelf.Where(Function(n) TypeOf n Is ExpressionSyntax And n.Span.Contains(expression.Span)).FirstOrDefault, ExpressionSyntax)

src\Analyzers\VisualBasic\CodeFixes\Iterator\VisualBasicConvertToIteratorCodeFixProvider.vb (1)

62Dim symbol = model.GetEnclosingSymbol(node.Span.Start, cancellationToken)

Structure\Providers\CollectionInitializerStructureProvider.vb (1)

40node.Span.End)

Structure\Providers\CompilationUnitStructureProvider.vb (1)

24Dim endPos = compilationUnit.Imports.Last().Span.End

Structure\Providers\InterpolatedStringExpressionStructureProvider.vb (1)

27textSpan:=node.Span,

Structure\Providers\ObjectCreationInitializerStructureProvider.vb (2)

34textSpan:=TextSpan.FromBounds(previousToken.Span.End, node.Span.End), 35hintSpan:=node.Parent.Span,

Structure\Providers\StringLiteralExpressionStructureProvider.vb (1)

24textSpan:=node.Span,

Structure\Providers\XmlExpressionStructureProvider.vb (1)

24Dim span = xmlExpression.Span

Structure\VisualBasicStructureHelpers.vb (4)

191blockNode.Span, GetHintSpan(blockNode), 203blockNode.Span, GetHintSpan(blockNode), 218Return TextSpan.FromBounds(child.SpanStart, blockNode.Span.End) 223Return blockNode.Span

Wrapping\SeparatedSyntaxList\VisualBasicCollectionCreationExpressionWrapper.vb (1)

66Return listSyntax.Span.Contains(position)

EditAndContinue\BreakpointSpansTests.vb (1)

84Dim endPosition = root.Span.End

Compilation\SemanticModelAPITests.vb (4)

936Dim position1 = originalStatement.Span.End 971Dim position1 = originalStatement.Span.End 1661Dim position1 = originalStatement.Span.End 1697Dim position1 = originalStatement.Span.End

Compilation\SemanticModelGetDeclaredSymbolAPITests.vb (7)

1008Assert.Equal(treeA.GetLineSpan(syntax.Span).StartLinePosition.Line, 1014Assert.Equal(treeA.GetLineSpan(syntax.Span).StartLinePosition.Line, 1020Assert.Equal(treeA.GetLineSpan(syntax.Span).StartLinePosition.Line, 1026Assert.Equal(treeA.GetLineSpan(syntax.Span).StartLinePosition.Line, 1032Assert.Equal(treeB.GetLineSpan(syntax.Span).StartLinePosition.Line, 1038Assert.Equal(treeB.GetLineSpan(syntax.Span).StartLinePosition.Line, 1047Assert.Equal(treeB.GetLineSpan(syntax.Span).StartLinePosition.Line,

FlowAnalysis\FlowTestBase.vb (3)

192If endPosition >= endNode.Span.End Then endPosition = endNode.Span.End 193While endNode IsNot Nothing AndAlso endNode.Span.End = endPosition

SymbolsTests\AnonymousTypes\AnonymousTypesSemanticsTests.vb (2)

1870Assert.True(statement1.Span.Contains(typeA3.Locations(0).SourceSpan)) 1871Assert.True(statement2.Span.Contains(typeA4.Locations(0).SourceSpan))

SymbolsTests\MyBaseMyClassSemanticsTests.vb (1)

78Dim span As TextSpan = node.Span

Syntax\SyntaxAnnotationTests.vb (1)

558Assert.Equal(oldNode.Span, annotatedNode.Span)

TestSyntaxNodes.vb (18)

ParserTestUtilities.vb (9)

375Assert.False(node.IsMissing, "Unexpected missing node: " & node.Kind.ToString & node.Span.ToString) 385Assert.True(0 <> node.Span.Length OrElse node.Kind = SyntaxKind.CompilationUnit, "Unexpected 0 width node: " & node.Kind.ToString & node.Span.ToString) 450node.Span.End <= node.Parent.Span.End, "Span of child (" & 451node.Kind.ToString & node.Span.ToString & 453node.Parent.Kind.ToString & node.Parent.Span.ToString & ")") 855node.Span.End <= node.Parent.Span.End, "Span of child (" & 858node.Parent.Kind.ToString & node.Parent.Span.ToString & ")")

Classification\Worker.DocumentationCommentClassifier.vb (1)

19If Not _worker._textSpan.OverlapsWith(documentationComment.Span) Then

Classification\Worker.vb (1)

171If Not _textSpan.OverlapsWith(skippedTokens.Span) Then

CodeCleanup\Providers\AddMissingTokensCodeCleanupProvider.vb (2)

333Dim span = originalNode.Span 568Return node IsNot Nothing AndAlso node.Span.Length > 0

CodeCleanup\Providers\NormalizeModifiersOrOperatorsCodeCleanupProvider.vb (3)

202Dim span = node.Span 242Dim span = node.Span 454Dim span = originalNode.Span

CodeGeneration\VisualBasicSyntaxGenerator.vb (8)

3327If root.Span.Contains(declaration.Span) Then 3407If root.Span.Contains(declaration.Span) Then 3433If root.Span.Contains(declaration.Span) Then 3547If root.Span.Contains(declaration.Span) Then

Rename\VisualBasicRenameRewriterLanguageService.vb (6)

169_conflictLocations.Contains(node.Span) AndAlso 179If Me._complexifiedSpans.Contains(originalNode.Span) Then 182Me._complexifiedSpans.Add(originalNode.Span) 200Dim oldSpan = originalNode.Span 233Dim newSpan = expandedNewNode.Span 249If Me._conflictLocations.Contains(node.Span) Then

Simplification\Reducers\VisualBasicVariableDeclaratorReducer.vb (2)

106issueSpan = variableDeclarator.Span 134issueSpan = variableDeclarator.Span

Simplification\Simplifiers\AbstractVisualBasicSimplifier.vb (1)

171boundSymbols = semanticModel.LookupNamespacesAndTypes(node.Span.Start, name:=aliasName + "Attribute")

Simplification\Simplifiers\ExpressionSimplifier.vb (8)

39issueSpan = memberAccessExpression.Expression.Span 92issueSpan = memberAccess.Span 119issueSpan = memberAccess.Span 124issueSpan = memberAccess.Expression.Span 143issueSpan = memberAccess.Span 158issueSpan = memberAccess.Expression.Span 261issueSpan = left.Span 281issueSpan = memberAccess.Name.Span

Simplification\Simplifiers\NameSimplifier.vb (10)

49issueSpan = genericName.TypeArgumentList.Span 66issueSpan = name.Span 103issueSpan = name.Span 111issueSpan = qualifiedName.Left.Span 181issueSpan = name.Span 209issueSpan = name.Span 231issueSpan = qualifiedName.Left.Span 336issueSpan = name.Right.Span 375issueSpan = New TextSpan(name.Span.End - 9, 9) 456Return Not name.Span.Contains(argumentDecl.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ParenthesizedExpressionSyntaxExtensions.vb (1)

142node.OpenParenToken.Span.End = expression.Span.Start Then

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxNodeExtensions.vb (5)

410Dim parentSpan = trivia.GetStructure().Span 415Dim matchSpan = match.Span 866If declaration.Initializer IsNot Nothing AndAlso declaration.Initializer.Span.Contains(span) Then 873If [property] IsNot Nothing AndAlso [property].Initializer IsNot Nothing AndAlso [property].Initializer.Span.Contains(span) Then 886Dim blockSpan = TextSpan.FromBounds(block.BlockStatement.Span.End, block.EndBlockStatement.SpanStart)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SyntaxFacts\VisualBasicSyntaxFacts.vb (1)

755If useFullSpan OrElse node.Span.Contains(position) Then

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\VisualBasicCodeGenerationService.vb (1)

85TextSpan.FromBounds(destination.Members.Last.Span.End, destination.EndOfFileToken.SpanStart), cancellationToken))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\TypeBlockSyntaxExtensions.vb (1)

19Dim start = destination.BlockStatement.Span.End

Workspace\LanguageServices\VisualBasicSyntaxTreeFactoryService.NodeSyntaxReference.vb (1)

26Return _node.Span

CodeCleanup\AbstractCodeCleanerService.cs (2)

205return TryCreateTextSpan(GetPreviousTokenStartPosition(previousTokenMarker.Type, previousToken), node.Span.End, out span); 226span = TextSpan.FromBounds(GetPreviousTokenStartPosition(previousTokenMarker.Type, previousToken), node.Span.End);

Differencing\AbstractSyntaxComparer.cs (1)

49=> node.Span;

LanguageServices\DeclaredSymbolFactoryService\AbstractDeclaredSymbolInfoFactoryService.cs (1)

316nameSyntax.Span,

ObsoleteSymbol\AbstractObsoleteSymbolService.cs (1)

72if (current.Span.IntersectsWith(span))

ReassignedVariable\AbstractReassignedVariableService.cs (3)

77if (current.Span.IntersectsWith(span)) 131result.Add(identifier.Span); 285localDeclaration.Span,

Recommendations\AbstractRecommendationServiceRunner.cs (1)

353declarationSyntax.Span.IntersectsWith(candidateLocation.SourceSpan)), declarationSyntax);

Rename\ConflictEngine\ConflictResolver.Session.cs (1)

435ComplexifiedTargetSpan: complexifiedTarget != null ? complexifiedTarget.Span : default));

Rename\ConflictEngine\RenamedSpansTracker.cs (1)

205AddComplexifiedSpan(documentId, oldSpan, node.Span, modifiedSubSpans);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationHelpers.cs (1)

221var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= info.Context.BeforeThisLocation.SourceSpan.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (6)

48if (selection.IsEmpty || node.Span.IsEmpty) 54if (selection.Contains(node.Span)) 81var beginningNode = node.FindToken(node.Span.Start).Parent; 82var endNode = node.FindToken(node.Span.End - 1).Parent; 93return beginningNode.Span.End <= selection.Start || endNode.Span.Start >= selection.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

172var affectedSpan = TextSpan.FromBounds(previousToken.SpanStart, FirstStatementAffectedInInnermostBlock.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsService.cs (3)

44=> x?.Span == y?.Span; 47=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

71return !semanticModel.SyntaxTree.OverlapsHiddenPosition(memberAccessExpression.Span, cancellationToken) &&

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NullableHelpers.cs (3)

43semanticFacts, semanticModel, rootOperation, declaredSymbol, rootOperation.Syntax.Span, includeDeclaration: true, cancellationToken) == true; 67if (!span.IntersectsWith(operation.Syntax.Span)) 70if (span.Contains(operation.Syntax.Span) &&

SyntaxReferenceTests.cs (1)

183Assert.Equal(0, node.Span.Length);

BindingSourceGenerator.cs (1)

161 NullableContext nullableContext = context.SemanticModel.GetNullableContext(context.Node.Span.Start);

ContractsCheckNameofFixProvider.cs (2)

92if (candidate.Span.Length < shortestSymbol) 95shortestSymbol = candidate.Span.Length;

CodeLens\RemoteCodeLensReferencesService.cs (4)

56(service, solutionInfo, cancellationToken) => service.GetReferenceCountAsync(solutionInfo, documentId, syntaxNode.Span, maxSearchResults, cancellationToken), 102(service, solutionInfo, cancellationToken) => service.FindReferenceMethodsAsync(solutionInfo, documentId, syntaxNode.Span, cancellationToken), 127(service, solutionInfo, cancellationToken) => service.GetFullyQualifiedNameAsync(solutionInfo, documentId, syntaxNode.Span, cancellationToken), 265(service, solutionInfo, cancellationToken) => service.FindReferenceLocationsAsync(solutionInfo, documentId, syntaxNode.Span, cancellationToken),

LanguageService\AbstractLanguageService`2.IVsLanguageBlock.cs (1)

93return (description, node.Span);

Venus\ContainedDocument.cs (2)

835if (current.Span.Start == visibleTextSpan.Start) 845if (current.Span.Start < visibleSpan.Start)

CodeModel\CSharpCodeModelService.NodeLocator.cs (19)

CodeModel\VisualBasicCodeModelService.NodeLocator.vb (35)

CodeModel\VisualBasicCodeModelService.vb (3)

4075position = methodStatement.HandlesClause.Span.End 4127text = text.Replace(methodStatement.HandlesClause.Span, String.Empty) 4135text = text.Replace(TextSpan.FromBounds(methodStatement.HandlesClause.Events.GetSeparator(index - 1).SpanStart, clauseItemToRemove.Span.End), String.Empty)

AbstractApplyTraitToClass`1.cs (2)

86.Single(attributeData => attributeData.ApplicationSyntaxReference is not null && attribute.Span.Contains(attributeData.ApplicationSyntaxReference.Span)); 106.Single(attributeData => attributeData.ApplicationSyntaxReference is not null && attribute.Span.Contains(attributeData.ApplicationSyntaxReference.Span));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationHelpers.cs (1)

221var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= info.Context.BeforeThisLocation.SourceSpan.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (6)

48if (selection.IsEmpty || node.Span.IsEmpty) 54if (selection.Contains(node.Span)) 81var beginningNode = node.FindToken(node.Span.Start).Parent; 82var endNode = node.FindToken(node.Span.End - 1).Parent; 93return beginningNode.Span.End <= selection.Start || endNode.Span.Start >= selection.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

172var affectedSpan = TextSpan.FromBounds(previousToken.SpanStart, FirstStatementAffectedInInnermostBlock.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsService.cs (3)

44=> x?.Span == y?.Span; 47=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

71return !semanticModel.SyntaxTree.OverlapsHiddenPosition(memberAccessExpression.Span, cancellationToken) &&

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NullableHelpers.cs (3)

43semanticFacts, semanticModel, rootOperation, declaredSymbol, rootOperation.Syntax.Span, includeDeclaration: true, cancellationToken) == true; 67if (!span.IntersectsWith(operation.Syntax.Span)) 70if (span.Contains(operation.Syntax.Span) &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\EmbeddedLanguages\VirtualChars\CSharpVirtualCharService.cs (1)

188var indentationLength = parentSourceText.Lines.GetLineFromPosition(parentExpression.Span.End).GetFirstNonWhitespaceOffset() ?? 0;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\BlockSyntaxExtensions.cs (3)

73conditionalDirectives.Last().Span.End >= block.CloseBraceToken.Span.End) 79if (conditionalDirectives.Last().Span.End <= statement.Span.Start)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs (1)

561var matchSpan = match.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\CSharpTriviaFormatter.DocumentationCommentExteriorCommentRewriter.cs (1)

75trivia.Span.End == currentParent.Span.End)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (2)

711if (useFullSpan || node.Span.Contains(position)) 919if (node.Span.IsEmpty)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\CompilationUnitSyntaxExtensions.cs (3)

43var end = usings.Last().Span.End; 52var end = rootUsings.Last().Span.End; 60: root.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\CSharpSyntaxContext.cs (1)

503lockStatement.Statement.Span.Contains(position))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\SyntaxTreeExtensions.cs (1)

683return declaration?.Name.Span.IntersectsWith(position) == true;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\TypeDeclarationSyntaxExtensions.cs (1)

46start = members.Last().Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpRemoveUnnecessaryImportsService.cs (1)

67spansToFormat.Add(TextSpan.FromBounds(baseNamespace.Name.Span.End, firstMemberB.SpanStart));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)

2217if (descendant.SpanStart <= afterNode.Span.End)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ParenthesizedExpressionSyntaxExtensions.vb (1)

142node.OpenParenToken.Span.End = expression.Span.Start Then

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxNodeExtensions.vb (5)

410Dim parentSpan = trivia.GetStructure().Span 415Dim matchSpan = match.Span 866If declaration.Initializer IsNot Nothing AndAlso declaration.Initializer.Span.Contains(span) Then 873If [property] IsNot Nothing AndAlso [property].Initializer IsNot Nothing AndAlso [property].Initializer.Span.Contains(span) Then 886Dim blockSpan = TextSpan.FromBounds(block.BlockStatement.Span.End, block.EndBlockStatement.SpanStart)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SyntaxFacts\VisualBasicSyntaxFacts.vb (1)

755If useFullSpan OrElse node.Span.Contains(position) Then

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\VisualBasicCodeGenerationService.vb (1)

85TextSpan.FromBounds(destination.Members.Last.Span.End, destination.EndOfFileToken.SpanStart), cancellationToken))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\TypeBlockSyntaxExtensions.vb (1)

19Dim start = destination.BlockStatement.Span.End

UpgradeToGeneratedRegexCodeFixer.cs (2)

140nodeToFix = root.FindNode(new TextSpan(nodeToFix.Span.Start + (typesModified * "partial".Length), nodeToFix.Span.Length), getInnermostNodeForTie: true);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

775!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationHelpers.cs (1)

221var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= info.Context.BeforeThisLocation.SourceSpan.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (6)

48if (selection.IsEmpty || node.Span.IsEmpty) 54if (selection.Contains(node.Span)) 81var beginningNode = node.FindToken(node.Span.Start).Parent; 82var endNode = node.FindToken(node.Span.End - 1).Parent; 93return beginningNode.Span.End <= selection.Start || endNode.Span.Start >= selection.End;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

172var affectedSpan = TextSpan.FromBounds(previousToken.SpanStart, FirstStatementAffectedInInnermostBlock.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsService.cs (3)

44=> x?.Span == y?.Span; 47=> obj.Span.GetHashCode();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

71return !semanticModel.SyntaxTree.OverlapsHiddenPosition(memberAccessExpression.Span, cancellationToken) &&

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NullableHelpers.cs (3)

43semanticFacts, semanticModel, rootOperation, declaredSymbol, rootOperation.Syntax.Span, includeDeclaration: true, cancellationToken) == true; 67if (!span.IntersectsWith(operation.Syntax.Span)) 70if (span.Contains(operation.Syntax.Span) &&