Span

src\roslyn\src\Analyzers\CSharp\CodeFixes\ConditionalExpressionInStringInterpolation\CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProvider.cs (1)

112var closeParenPosition = endToken.Span.End;

src\roslyn\src\Analyzers\CSharp\CodeFixes\ConvertNamespace\ConvertNamespaceTransform.cs (2)

89return (updatedRoot, fileScopedNamespace.SemicolonToken.Span); 126return (dedentedText, fileScopedNamespace.SemicolonToken.Span);

src\roslyn\src\Analyzers\CSharp\CodeFixes\NewLines\ArrowExpressionClausePlacement\ArrowExpressionClausePlacementCodeFixProvider.cs (1)

80var end = token.Span.End;

src\roslyn\src\Analyzers\CSharp\CodeFixes\NewLines\ConditionalExpressionPlacement\ConditionalExpressionPlacementCodeFixProvider.cs (1)

82var end = token.Span.End;

src\roslyn\src\Analyzers\CSharp\CodeFixes\ReplaceDefaultLiteral\CSharpReplaceDefaultLiteralCodeFixProvider.cs (1)

43if (token.Span == context.Span &&

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

59? firstMember.GetFirstToken().Span.End

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

547var existingAccessorSpan = existingAccessor.Span;

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

890if (firstConstructorConstraint == null || firstConstructorConstraint.SpanStart > token.Span.End) 2384position >= token.Span.End)

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

120if (token.Span.End <= position) 121stack += token.Span.Length; 123stack += (position - token.Span.Start);

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

27var start = destination.OpenBraceToken.Span.End; 34var start = destination.OpenBraceToken.Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Indentation\CSharpIndentationService.Indenter.cs (2)

83var endLine = sourceText.Lines.GetLineFromPosition(token.Span.End); 127var endLine = sourceText.Lines.GetLineFromPosition(interpolatedExpression.StringEndToken.Span.End);

BraceCompletion\AbstractCurlyBraceOrBracketCompletionService.cs (1)

128closingPoint = annotatedNewline.Token.Span.End;

BraceCompletion\InterpolatedStringBraceCompletionService.cs (1)

43=> IsValidOpeningBraceToken(token) && token.Span.End - 1 == position;

BraceCompletion\InterpolationBraceCompletionService.cs (1)

61if (!token.Span.IntersectsWith(position))

BraceCompletion\ParenthesisBraceCompletionService.cs (2)

44if (closeParen.Kind() != SyntaxKind.CloseParenToken || closeParen.Span.Length == 0) 68return text.Lines.GetLineFromPosition(openParen.SpanStart).LineNumber == text.Lines.GetLineFromPosition(closeParen.Span.End).LineNumber;

BraceCompletion\StringLiteralBraceCompletionService.cs (1)

75token.Span.Length > 1 &&

BraceMatching\BlockCommentBraceMatcher.cs (2)

28var span = token.Span; 36else if (position >= token.Span.End)

BraceMatching\CSharpDirectiveTriviaBraceMatcher.cs (1)

36=> TextSpan.FromBounds(directive.HashToken.SpanStart, directive.DirectiveNameToken.Span.End);

BraceMatching\StringLiteralBraceMatcher.cs (6)

45return new BraceMatchingResult(token.Span, interpolatedString.StringEndToken.Span); 52return new BraceMatchingResult(interpolatedString.StringStartToken.Span, token.Span); 66new TextSpan(token.Span.End - endTokenLength, endTokenLength)); 72new TextSpan(token.Span.End - endTokenLength, endTokenLength));

ChangeSignature\ChangeSignatureFormattingRule.cs (1)

46span = TextSpan.FromBounds(Math.Max(baseToken.Span.End, span.Start), span.End);

ChangeSignature\CSharpChangeSignatureService.cs (1)

127position = token.Span.End;

CodeLens\CSharpCodeLensMemberFinder.cs (14)

CodeRefactorings\SyncNamespace\CSharpSyncNamespaceCodeRefactoringProvider.cs (1)

49&& firstMemberDeclarationName.Span.IntersectsWith(position))

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

185var end = token.Span.End;

Completion\CompletionProviders\OperatorsAndIndexer\UnnamedSymbolCompletionProvider.cs (1)

200new TextChange(TextSpan.FromBounds(replacementStart, tokenOnLeft.Span.End), text),

Completion\CompletionProviders\OperatorsAndIndexer\UnnamedSymbolCompletionProvider_Conversions.cs (1)

120builder.Add(new TextChange(tokenOnLeft.Span, ""));

Completion\CompletionProviders\OperatorsAndIndexer\UnnamedSymbolCompletionProvider_Operators.cs (2)

147dotLikeToken.Kind() == SyntaxKind.DotDotToken ? dotLikeToken.Span.Start + 1 : dotLikeToken.Span.End),

Completion\CompletionProviders\SymbolCompletionProvider.cs (2)

192if (token.Span.End > characterPosition + 1) 198for (var i = token.Span.End; i < characterPosition; i++)

Completion\KeywordRecommenders\InKeywordRecommender.cs (1)

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

Completion\KeywordRecommenders\NewKeywordRecommender.cs (2)

63.Any(t => token.SpanStart > t.OpenBraceToken.Span.End && 64token.Span.End < t.CloseBraceToken.SpanStart);

ConvertNamespace\ConvertNamespaceCodeRefactoringProvider.cs (1)

79return position <= fileScopedNamespace.SemicolonToken.Span.End;

ConvertToRawString\ConvertInterpolatedStringToRawStringCodeRefactoringProvider.cs (2)

493interpolationInteriorSpans.Add(TextSpan.FromBounds(interpolation.OpenBraceToken.Span.End, interpolation.CloseBraceToken.Span.Start));

ConvertToRawString\ConvertStringToRawStringCodeRefactoringProvider.cs (4)

76if (!context.Span.IntersectsWith(token.Span)) 102token.Span); 112token.Span); 122token.Span);

Debugging\DataTipInfoGetter.cs (1)

33? new DebugDataTipInfo(token.Span, text: null)

EditAndContinue\BreakpointSpans.cs (9)

111=> TextSpan.FromBounds(startToken.SpanStart, endToken.Span.End); 117=> TextSpan.FromBounds(node.SpanStart, token.Span.End); 120=> TextSpan.FromBounds(token.SpanStart, token.Span.End); 161return nodeOrToken.AsNode()!.GetLastToken().Span.End; 222if (position < typeDeclaration.ParameterList.CloseParenToken.Span.End) 306position >= switchExpression.OpenBraceToken.Span.End && 307position <= switchExpression.CloseBraceToken.Span.Start: 443position > constructorSyntax.ExpressionBody.ArrowToken.Span.Start) 669if (position < forEachStatement.OpenParenToken.Span.End || position > forEachStatement.CloseParenToken.SpanStart)

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (56)

265Debug.Assert(span.End == switchExpression.CloseBraceToken.Span.End); 307=> position < node.OpenBraceToken.Span.End ? BlockPart.OpenBrace : BlockPart.CloseBrace; 312BlockPart.OpenBrace => node.OpenBraceToken.Span, 313BlockPart.CloseBrace => node.CloseBraceToken.Span, 326ForEachPart.ForEach => node.ForEachKeyword.Span, 327ForEachPart.VariableDeclaration => TextSpan.FromBounds(node.Type.SpanStart, node.Identifier.Span.End), 328ForEachPart.In => node.InKeyword.Span, 336ForEachPart.ForEach => node.ForEachKeyword.Span, 338ForEachPart.In => node.InKeyword.Span, 347SwitchExpressionPart.SwitchBody => TextSpan.FromBounds(node.SwitchKeyword.SpanStart, node.CloseBraceToken.Span.End), 577=> BreakpointSpans.TryGetClosestBreakpointSpan(token.Parent!, token.SpanStart, minLength: token.Span.Length, out span); 1268oldTypeDeclaration.Identifier.Span != newTypeDeclaration.Identifier.Span || 1648return extensionBlockDeclaration.Keyword.Span; 1726return typeParameter.Identifier.Span; 1759return ((BlockSyntax)node).OpenBraceToken.Span; 1763return TextSpan.FromBounds(usingStatement.UsingKeyword.SpanStart, usingStatement.CloseParenToken.Span.End); 1767return TextSpan.FromBounds(fixedStatement.FixedKeyword.SpanStart, fixedStatement.CloseParenToken.Span.End); 1771return TextSpan.FromBounds(lockStatement.LockKeyword.SpanStart, lockStatement.CloseParenToken.Span.End); 1774return ((StackAllocArrayCreationExpressionSyntax)node).StackAllocKeyword.Span; 1777return ((ImplicitStackAllocArrayCreationExpressionSyntax)node).StackAllocKeyword.Span; 1780return ((TryStatementSyntax)node).TryKeyword.Span; 1783return ((CatchClauseSyntax)node).CatchKeyword.Span; 1790return ((FinallyClauseSyntax)node).FinallyKeyword.Span; 1794return TextSpan.FromBounds(ifStatement.IfKeyword.SpanStart, ifStatement.CloseParenToken.Span.End); 1797return ((ElseClauseSyntax)node).ElseKeyword.Span; 1802(switchStatement.CloseParenToken != default) ? switchStatement.CloseParenToken.Span.End : switchStatement.Expression.Span.End); 1809return TextSpan.FromBounds(whileStatement.WhileKeyword.SpanStart, whileStatement.CloseParenToken.Span.End); 1812return ((DoStatementSyntax)node).DoKeyword.Span; 1816return TextSpan.FromBounds(forStatement.ForKeyword.SpanStart, forStatement.CloseParenToken.Span.End); 1822(commonForEachStatement.AwaitKeyword.Span.Length > 0) ? commonForEachStatement.AwaitKeyword.SpanStart : commonForEachStatement.ForEachKeyword.SpanStart, 1823commonForEachStatement.CloseParenToken.Span.End); 1826return ((LabeledStatementSyntax)node).Identifier.Span; 1830return ((CheckedStatementSyntax)node).Keyword.Span; 1833return ((UnsafeStatementSyntax)node).UnsafeKeyword.Span; 1837return lfd.Identifier.Span; 1854return CombineSpans(localDeclarationStatement.AwaitKeyword.Span, localDeclarationStatement.UsingKeyword.Span, node.Span); 1857return ((AwaitExpressionSyntax)node).AwaitKeyword.Span; 1860return ((AnonymousObjectCreationExpressionSyntax)node).NewKeyword.Span; 1870return ((AnonymousMethodExpressionSyntax)node).DelegateKeyword.Span; 1873return ((QueryExpressionSyntax)node).FromClause.FromKeyword.Span; 1880return ((QueryContinuationSyntax)node).IntoKeyword.Span; 1883return ((FromClauseSyntax)node).FromKeyword.Span; 1886return ((JoinClauseSyntax)node).JoinKeyword.Span; 1889return ((JoinIntoClauseSyntax)node).IntoKeyword.Span; 1892return ((LetClauseSyntax)node).LetKeyword.Span; 1895return ((WhereClauseSyntax)node).WhereKeyword.Span; 1898return ((OrderByClauseSyntax)node).OrderByKeyword.Span; 1905return ((SelectClauseSyntax)node).SelectKeyword.Span; 1908return ((GroupClauseSyntax)node).GroupKeyword.Span; 1924return ((SwitchExpressionSyntax)node).SwitchKeyword.Span; 1927return ((SwitchExpressionArmSyntax)node).EqualsGreaterThanToken.Span; 1947return ((ParenthesizedLambdaExpressionSyntax)lambda).ParameterList.Parameters[ordinal].Identifier.Span; 1951return ((SimpleLambdaExpressionSyntax)lambda).Parameter.Identifier.Span; 1955return ((AnonymousMethodExpressionSyntax)lambda).ParameterList!.Parameters[ordinal].Identifier.Span;

EmbeddedLanguages\CSharpTestEmbeddedLanguageClassifier.cs (2)

68var firstLine = lines.GetLineFromPosition(token.Span.Start); 69var lastLine = lines.GetLineFromPosition(token.Span.End);

ExtractMethod\CSharpSelectionValidator.cs (3)

51if (firstTokenInSelection.SpanStart > lastTokenInSelection.Span.End) 207=> token.GetAncestors<SyntaxNode>().Any(n => CheckTopLevel(n, token.Span)); 252var blockSpan = TextSpan.FromBounds(block.OpenBraceToken.Span.End, block.CloseBraceToken.SpanStart);

GoToDefinition\CSharpGoToDefinitionSymbolService.cs (3)

38? foundContinuedLoop.GetFirstToken().Span.Start 50? foundBrokenLoop.GetLastToken().Span.End 66return foundReturnableConstruct.GetFirstToken().Span.Start;

Highlighting\KeywordHighlighters\AsyncAwaitHighlighter.cs (3)

108if (lastSpan == previousToken.Span) 110spans[^1] = TextSpan.FromBounds(lastSpan.Start, mod.Span.End); 115spans.Add(mod.Span);

Highlighting\KeywordHighlighters\CheckedExpressionHighlighter.cs (1)

28=> highlights.Add(checkedExpressionSyntax.Keyword.Span);

Highlighting\KeywordHighlighters\CheckedStatementHighlighter.cs (1)

28=> highlights.Add(checkedStatement.Keyword.Span);

Highlighting\KeywordHighlighters\ConditionalPreprocessorHighlighter.cs (1)

30conditional.DirectiveNameToken.Span.End));

Highlighting\KeywordHighlighters\IfStatementHighlighter.cs (5)

43highlights.Add(ifStatement.IfKeyword.Span); 58elseIfStatement.IfKeyword.Span.End)); 63highlights.Add(elseKeyword.Span); 64highlights.Add(elseIfStatement.IfKeyword.Span); 73highlights.Add(elseKeyword.Span);

Highlighting\KeywordHighlighters\LockStatementHighlighter.cs (1)

28=> highlights.Add(lockStatement.LockKeyword.Span);

Highlighting\KeywordHighlighters\LoopHighlighter.cs (10)

62spans.Add(statement.DoKeyword.Span); 63spans.Add(statement.WhileKeyword.Span); 64spans.Add(EmptySpan(statement.SemicolonToken.Span.End)); 68=> spans.Add(statement.ForKeyword.Span); 71=> spans.Add(statement.ForEachKeyword.Span); 74=> spans.Add(statement.WhileKeyword.Span); 86spans.Add(breakStatement.BreakKeyword.Span); 87spans.Add(EmptySpan(breakStatement.SemicolonToken.Span.End)); 91spans.Add(continueStatement.ContinueKeyword.Span); 92spans.Add(EmptySpan(continueStatement.SemicolonToken.Span.End));

Highlighting\KeywordHighlighters\RegionHighlighter.cs (2)

39directive.DirectiveNameToken.Span.End)); 43matchingDirective.DirectiveNameToken.Span.End));

Highlighting\KeywordHighlighters\ReturnStatementHighlighter.cs (2)

53spans.Add(statement.ReturnKeyword.Span); 54spans.Add(EmptySpan(statement.SemicolonToken.Span.End));

Highlighting\KeywordHighlighters\SwitchStatementHighlighter.cs (8)

39spans.Add(switchStatement.SwitchKeyword.Span); 45spans.Add(label.Keyword.Span); 46spans.Add(EmptySpan(label.ColonToken.Span.End)); 64spans.Add(breakStatement.BreakKeyword.Span); 65spans.Add(EmptySpan(breakStatement.SemicolonToken.Span.End)); 77? gotoStatement.CaseOrDefaultKeyword.Span.End 78: gotoStatement.GotoKeyword.Span.End; 81spans.Add(EmptySpan(gotoStatement.SemicolonToken.Span.End));

Highlighting\KeywordHighlighters\TryStatementHighlighter.cs (4)

30highlights.Add(tryStatement.TryKeyword.Span); 34highlights.Add(catchDeclaration.CatchKeyword.Span); 38highlights.Add(catchDeclaration.Filter.WhenKeyword.Span); 44highlights.Add(tryStatement.Finally.FinallyKeyword.Span);

Highlighting\KeywordHighlighters\UnsafeStatementHighlighter.cs (1)

28=> highlights.Add(unsafeStatement.UnsafeKeyword.Span);

Highlighting\KeywordHighlighters\UsingStatementHighlighter.cs (1)

28=> highlights.Add(usingStatement.UsingKeyword.Span);

Highlighting\KeywordHighlighters\YieldStatementHighlighter.cs (2)

56statement.ReturnOrBreakKeyword.Span.End)); 58spans.Add(EmptySpan(statement.SemicolonToken.Span.End));

InlineHints\CSharpInlineTypeHintsService.cs (1)

94var span = new TextSpan(implicitNew.NewKeyword.Span.End, 0);

LineSeparators\CSharpLineSeparatorService.cs (1)

350return node.GetLastToken().Span;

MoveToNamespace\CSharpMoveToNamespaceService.cs (1)

42FileScopedNamespaceDeclarationSyntax fileScopedNamespace => fileScopedNamespace.SemicolonToken.Span.End,

NavigationBar\CSharpNavigationBarItemService.cs (1)

305var end = enumDeclaration.Members.GetSeparator(index).Span.End;

QuickInfo\CSharpSemanticQuickInfoProvider.cs (1)

126if (nameSyntax is null || !nameSyntax.Span.Contains(token.Span))

QuickInfo\CSharpSyntacticQuickInfoProvider.cs (4)

67var spanEnd = openBrace.Span.End; 85return QuickInfoItem.Create(token.Span, relatedSpans: spans); 138return QuickInfoItem.Create(token.Span, relatedSpans: [regionStart.Span]); 147return QuickInfoItem.Create(token.Span, relatedSpans: matchesBefore);

RawStringLiteral\CSharpRawStringLiteralOnAutoInsertService.cs (1)

159if (token.Span.Length < (2 * quoteCount))

Snippets\AbstractCSharpAutoPropertySnippetProvider.cs (1)

76=> propertyDeclaration.AccessorList!.CloseBraceToken.Span.End;

SolutionCrawler\CSharpDocumentDifferenceService.cs (1)

40=> TextSpan.FromBounds(body.OpenBraceToken.Span.End, body.CloseBraceToken.SpanStart);

SplitStringLiteral\SimpleStringSplitter.cs (4)

33return _token.IsKind(SyntaxKind.Utf8StringLiteralToken) && CursorPosition >= _token.Span.End - "u8".Length; 42var suffix = Document.Text.GetSubText(TextSpan.FromBounds(CursorPosition, _token.Span.End)).ToString(); 47? Document.Text.GetSubText(TextSpan.FromBounds(_token.Span.End - "u8".Length, _token.Span.End)).ToString()

src\roslyn\src\Analyzers\CSharp\Analyzers\ConvertNamespace\ConvertToBlockScopedNamespaceDiagnosticAnalyzer.cs (1)

54: declaration.SyntaxTree.GetLocation(TextSpan.FromBounds(declaration.SpanStart, declaration.SemicolonToken.Span.End));

src\roslyn\src\Analyzers\CSharp\Analyzers\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessAnalyzer.cs (3)

183var fadeLocation = Location.Create(tree, TextSpan.FromBounds(firstStatement.SpanStart, previousToken.Span.End)); 202if (nextToken.Span.Start < ifStatement.Span.End) 204fadeLocation = Location.Create(tree, TextSpan.FromBounds(nextToken.Span.Start, ifStatement.Span.End));

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

31CastExpressionSyntax cast => TextSpan.FromBounds(cast.OpenParenToken.SpanStart, cast.CloseParenToken.Span.End),

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

222: ((ImplicitArrayCreationExpressionSyntax)expression).CloseBracketToken.Span.End)));

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForCreateDiagnosticAnalyzer.cs (1)

62invocationExpression.ArgumentList.OpenParenToken.Span.End)),

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs (1)

104objectCreationExpression.ArgumentList.OpenParenToken.Span.End)),

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

72expression.CloseBracketToken.Span.End)));

src\roslyn\src\Analyzers\CSharp\Analyzers\UseDefaultLiteral\CSharpUseDefaultLiteralDiagnosticAnalyzer.cs (1)

45var fadeSpan = TextSpan.FromBounds(defaultExpression.OpenParenToken.SpanStart, defaultExpression.CloseParenToken.Span.End);

src\roslyn\src\Analyzers\CSharp\Analyzers\UseExpressionBodyForLambda\UseExpressionBodyForLambdaDiagnosticAnalyzer.cs (1)

105TextSpan.FromBounds(declaration.SpanStart, declaration.ArrowToken.Span.End));

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

50var fadeSpan = TextSpan.FromBounds(nameColon.Name.SpanStart, nameColon.ColonToken.Span.End); 76var fadeSpan = TextSpan.FromBounds(nameEquals.Name.SpanStart, nameEquals.EqualsToken.Span.End);

src\roslyn\src\Analyzers\CSharp\Analyzers\UseUnboundGenericTypeInNameOf\CSharpUseUnboundGenericTypeInNameOfDiagnosticAnalyzer.cs (2)

81TextSpan.FromBounds(typeArgumentList.LessThanToken.Span.End, typeArgumentList.GreaterThanToken.Span.Start))]));