Length

Text\TextSpan.cs (1)

SourceGenerator.cs (1)

187=> _builder.ToString(span.Start, span.Length);

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

70bool OverlapsWithSpan(SyntaxNode n) => spansTree.HasIntervalThatOverlapsWith(n.FullSpan.Start, n.FullSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

373if (p.Length > 0 && char.IsLetter(name[p.Start])) 374return name.Substring(p.Start, p.Length).ToCamelCase();

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

147=> !spansTree.HasIntervalThatOverlapsWith(nodeOrToken.FullSpan.Start, nodeOrToken.FullSpan.Length);

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

InternalReferencedInPublicDocAnalyzerTests.cs (1)

471var text = source.Substring(location.SourceSpan.Start, location.SourceSpan.Length);

Infrastructure\VirtualChars\AbstractVirtualCharService.cs (1)

176index += result[result.Count - 1].Span.Length;

Infrastructure\VirtualChars\CSharpVirtualCharService.cs (3)

225lineStart = lineSpan.Length > indentationLength 281index += charResults.Last().span.Length; 291index += charResults.Last().span.Length;

Infrastructure\VirtualChars\VirtualCharSequence.cs (2)

73public int Length => _span.Length; 91=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

RouteEmbeddedLanguage\FrameworkParametersCompletionProvider.cs (1)

260properties.Add(LengthKey, textChange.Span.Length.ToString(CultureInfo.InvariantCulture));

RouteEmbeddedLanguage\Infrastructure\SyntaxNodeExtensions.cs (2)

104if (token.Span.Length == 0) 138if (token.Span.Length > 0 && token.SpanStart <= position)

RouteEmbeddedLanguage\RoutePatternCompletionProvider.cs (1)

139properties.Add(LengthKey, textChange.Span.Length.ToString(CultureInfo.InvariantCulture));

WebApplicationBuilder\WebApplicationBuilderAnalyzer.cs (1)

294var fullSyntaxLength = location.SourceSpan.Length;

RouteEmbeddedLanguage\RoutePatternClassifierTests.cs (1)

33var actualFormatted = actualOrdered.Select(a => new FormattedClassification(rewrittenCode.Substring(a.TextSpan.Start, a.TextSpan.Length), a.ClassificationType)).ToArray();

Diagnostic\SourceLocation.cs (1)

130return base.GetDebuggerDisplay() + "\"" + _syntaxTree.ToString().Substring(_span.Start, _span.Length) + "\"";

DiagnosticAnalyzer\AnalysisScope.cs (1)

170if (filterSpan.GetValueOrDefault().Start == 0 && filterSpan.GetValueOrDefault().Length == filterFile.GetValueOrDefault().SourceTree!.Length)

Syntax\SyntaxDiffer.cs (21)

116delta += change.Range.NewLength - change.Range.Span.Length; 311if (sim >= Math.Max(_oldNodes.Peek().FullSpan.Length, _newNodes.Peek().FullSpan.Length)) 329if (child.FullSpan.Length > 0) 359var sim = node.FullSpan.Length; 373if (sim == node.FullSpan.Length && node.IsToken) 405similarity = node.FullSpan.Length; 460w += tr.FullSpan.Length; 469w += tr.FullSpan.Length; 491w += n2.FullSpan.Length; 550RecordChange(new TextChangeRange(oldSpan, newSpan.Length), removedNode, insertedNode); 560RecordChange(new ChangeRecord(new TextChangeRange(oldSpan, newSpan.Length), removedNodes, insertedNodes)); 570RecordChange(new ChangeRecord(new TextChangeRange(new TextSpan(start, 0), newSpan.Length), null, insertedNodes)); 582new TextChangeRange(new TextSpan(last.Range.Span.Start, last.Range.Span.Length + change.Range.Span.Length), last.Range.NewLength + change.Range.NewLength), 605new TextChangeRange(new TextSpan(last.Range.Span.Start, last.Range.Span.Length + textChangeRange.Span.Length), last.Range.NewLength + textChangeRange.NewLength), 749if (cr.Range.Span.Length > 0 && cr.Range.NewLength > 0) 764new TextSpan(range.Span.Start + commonLeadingCount, range.Span.Length - (commonLeadingCount + commonTrailingCount)), 779if (range.Span.Length > 0 || range.NewLength > 0) 828var builder = new StringBuilder(span.Length);

Syntax\SyntaxNode.Iterators.cs (1)

42|| (childSpan.Length == 0 && span.IntersectsWith(childSpan));

Text\ChangedText.cs (1)

38deltaLength += change.NewLength - change.Span.Length;

Text\CompositeText.cs (4)

88var count = span.Length; 504var lineLength = firstSegmentTextLine.SpanIncludingLineBreak.Length; 517lineLength += nextSegment.Lines[0].SpanIncludingLineBreak.Length; 527lineLength += lastSegment.Lines[0].SpanIncludingLineBreak.Length;

Text\LargeText.cs (1)

189int count = span.Length;

Text\SourceText.cs (3)

503int spanLength = span.Length; 792if (change.Span.Length == 0 && newTextLength == 0) 924newPosDelta += range.NewLength - range.Span.Length;

Text\StringBuilderText.cs (1)

85return _builder.ToString(span.Start, span.Length);

Text\StringText.cs (2)

78if (span.Start == 0 && span.Length == this.Length) 83return this.Source.Substring(span.Start, span.Length);

Text\SubText.cs (5)

43public override int Length => UnderlyingSpan.Length; 75return UnderlyingText.ToString(GetCompositeSpan(span.Start, span.Length)); 82return new SubText(UnderlyingText, GetCompositeSpan(span.Start, span.Length)); 88UnderlyingText.CopyTo(span.Start, destination, destinationIndex, span.Length); 205if (position < 0 || position > _subText.UnderlyingSpan.Length)

Text\TextChange.cs (1)

108return $"new TextChange(new TextSpan({Span.Start}, {Span.Length}), {newTextDisplay})";

Text\TextChangeRange.cs (3)

108diff += change.NewLength - change.Span.Length; 128var newLen = combined.Length + diff; 135return $"new TextChangeRange(new TextSpan({Span.Start}, {Span.Length}), {NewLength})";

Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

Text\TextLine.cs (1)

67span = new TextSpan(span.Start, span.Length + lineBreakLen);

Text\TextSpan.cs (9)

47public int End => Start + Length; 58public bool IsEmpty => this.Length == 0; 72return unchecked((uint)(position - Start) < (uint)Length); 156return unchecked((uint)(position - Start) <= (uint)Length); 221return Start == other.Start && Length == other.Length; 235return Hash.Combine(Start, Length); 259return Length - other.Length;

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (1)

683var locationInfo = $"{span.Start}{AdditionalDocumentLocationInfoSeparator}{span.Length}{AdditionalDocumentLocationInfoSeparator}{fixLocation.GetLineSpan().Path}";

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

70bool OverlapsWithSpan(SyntaxNode n) => spansTree.HasIntervalThatOverlapsWith(n.FullSpan.Start, n.FullSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

373if (p.Length > 0 && char.IsLetter(name[p.Start])) 374return name.Substring(p.Start, p.Length).ToCamelCase();

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

147=> !spansTree.HasIntervalThatOverlapsWith(nodeOrToken.FullSpan.Start, nodeOrToken.FullSpan.Length);

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

70bool OverlapsWithSpan(SyntaxNode n) => spansTree.HasIntervalThatOverlapsWith(n.FullSpan.Start, n.FullSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

373if (p.Length > 0 && char.IsLetter(name[p.Start])) 374return name.Substring(p.Start, p.Length).ToCamelCase();

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

147=> !spansTree.HasIntervalThatOverlapsWith(nodeOrToken.FullSpan.Start, nodeOrToken.FullSpan.Length);

src\Analyzers\Core\Analyzers\Formatting\AbstractFormattingAnalyzer.cs (1)

69var offset = change.Span.Length - change.NewText.Length;

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

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

70bool OverlapsWithSpan(SyntaxNode n) => spansTree.HasIntervalThatOverlapsWith(n.FullSpan.Start, n.FullSpan.Length);

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

147=> !spansTree.HasIntervalThatOverlapsWith(nodeOrToken.FullSpan.Start, nodeOrToken.FullSpan.Length);

Compiler\UnprocessedDocumentationCommentFinder.cs (1)

56if (node.Span.Length > 0)

FlowAnalysis\AbstractFlowPass.cs (2)

299Debug.Assert(span.Length > 0); 300if (span.Length == 0)

FlowAnalysis\ControlFlowPass.cs (1)

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

Lowering\Instrumentation\CodeCoverageInstrumenter.cs (1)

631return new TextSpan(startSpan.Start, originalSpan.Length - (startSpan.Start - originalSpan.Start));

Parser\Blender.Reader.cs (1)

134_changeDelta += change.NewLength - change.Span.Length;

Symbols\Source\SourceConstructorSymbolBase.cs (1)

206ctorInitializerLength = span.Length;

Symbols\Source\SourceMemberContainerSymbol.cs (2)

1115aggregateLength += syntaxRef.Span.Length; 1245return initializer.Syntax.Span.Length;

Symbols\Symbol.cs (1)

510if (location.SourceSpan.Length != 0)

Syntax\CSharpSyntaxTree.ParsedSyntaxTree.cs (1)

85get { return _root.FullSpan.Length; }

Syntax\SyntaxTreeDiagnosticEnumerator.cs (1)

62var length = _syntaxTree.GetRoot().FullSpan.Length;

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

52if (_ignoredSpans.HasIntervalThatContains(node.SpanStart, node.Span.Length))

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

213lineStart = lineSpan.Length > indentationLength

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxTreeExtensions.cs (4)

370return token.Span.Length == startDelimiterLength || 371(token.Span.Length > startDelimiterLength && endDelimiterLength < startDelimiterLength); 376return token.Span.Length == startDelimiterLength || 377(token.Span.Length > startDelimiterLength && token.Text[^1] != lastChar);

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

132var initialColumn = (token1.RawKind == 0) ? 0 : this.TreeInfo.GetOriginalColumn(Options.TabSize, token1) + token1.Span.Length;

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

182while (commonIndentation < indentation.Length && commonIndentation < textLine.Span.Length)

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

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

BlockCommentEditing\BlockCommentEditingCommandHandler.cs (1)

303if (span.Length < "/**/".Length)

Interactive\CSharpSendToInteractiveSubmissionProvider.cs (1)

125startToken = selectionSpan.Length == 0

StringCopyPaste\StringCopyPasteHelpers.cs (3)

529for (var n = Math.Min(commonIndentPrefix.Length, lineWhitespaceSpan.Length); commonPrefixLength < n; commonPrefixLength++) 550if (spans.First().Length > 0 && text[spans.First().Start] == '"') 553if (spans.Last().Length > 0 && text[spans.Last().End - 1] == '"')

ExtractMethod\ExtractMethodMiscellaneousTests.cs (1)

139view.TextBuffer.CurrentSnapshot, testDocument.SelectedSpans[0].Start, testDocument.SelectedSpans[0].Length), isReversed: false);

FlowAnalysis\RegionAnalysisTests.cs (1)

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

BraceCompletion\StringLiteralBraceCompletionService.cs (1)

75token.Span.Length > 1 &&

Debugging\CSharpBreakpointResolutionService.cs (1)

41if (span.Length == 0)

Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.cs (6)

144if (_ignoredSpans?.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) ?? false) 161if (_ignoredSpans?.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) ?? false) 178if (_ignoredSpans?.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) ?? false) 195if (_ignoredSpans?.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) ?? false) 233if (_ignoredSpans?.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) ?? false) 250if (_ignoredSpans?.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) ?? false)

EditAndContinue\BreakpointSpans.cs (1)

94if (breakpointSpan.Value.Length >= minLength)

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (6)

578=> BreakpointSpans.TryGetClosestBreakpointSpan(token.Parent!, token.SpanStart, minLength: token.Span.Length, out span); 1819(commonForEachStatement.AwaitKeyword.Span.Length > 0) ? commonForEachStatement.AwaitKeyword.SpanStart : commonForEachStatement.ForEachKeyword.SpanStart, 1935=> (first.Length > 0 && second.Length > 0) ? TextSpan.FromBounds(first.Start, second.End) : (first.Length > 0) ? first : (second.Length > 0) ? second : defaultSpan;

InlineHints\CSharpInlineTypeHintsService.cs (1)

133var trailingSpace = span.Length == 0;

SplitOrMergeIfStatements\CSharpMergeConsecutiveIfStatementsCodeRefactoringProvider.cs (2)

36if (span.Length == 0 || 51if (span.Length == 0 ||

SplitOrMergeIfStatements\CSharpMergeNestedIfStatementsCodeRefactoringProvider.cs (2)

36if (span.Length == 0 || 51if (span.Length == 0 ||

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

52if (_ignoredSpans.HasIntervalThatContains(node.SpanStart, node.Span.Length))

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

182while (commonIndentation < indentation.Length && commonIndentation < textLine.Span.Length)

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

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

EditAndContinue\BreakpointSpansTests.cs (4)

47Assert.True(breakpointSpan.Length == 0); 59message: $"Expected: [|{source.Substring(expectedSpan.Value.Start, expectedSpan.Value.Length)}|], Actual: [|{source.Substring(breakpointSpan.Start, breakpointSpan.Length)}|]"); 83itemInspector: span => "[|" + source.Substring(span.Start, span.Length) + "|]");

EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (2)

49var expectedText = source.Substring(expected.Start, expected.Length); 58var actualText = source.Substring(actual.Start, actual.Length);

EditAndContinue\SyntaxUtilitiesTests.cs (1)

24foreach (var oldNode in oldRoot.DescendantNodes().Where(n => n.FullSpan.Length > 0))

Diagnostics\LocationsTests.cs (4)

562Assert.Equal(5, treeSpan.Length); 568Assert.Equal(0, diagnostics[0].Location.SourceSpan.Length); 590Assert.Equal(0, treeSpan.Length); 596Assert.Equal(0, diagnostics[0].Location.SourceSpan.Length);

LexicalAndXml\LexicalTests.cs (26)

Parsing\ScriptParsingTests.cs (1)

9740Assert.Equal(0, endOfDirective.Span.Length);

Syntax\SyntaxNodeTests.cs (20)

Classification\ClassificationHelpers.cs (2)

534if (token.Span.Length == span.Length)

Classification\Worker.cs (1)

61=> span.Length > 0 && _textSpan.OverlapsWith(span);

Rename\CSharpRenameRewriterLanguageService.cs (2)

109newSpan = new TextSpan(oldSpan.Start, newSpan.Length); 314_renameSpansTracker.AddComplexifiedSpan(_documentId, oldSpan, new TextSpan(oldSpan.Start, newSpan.Length), _modifiedSubSpans);

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

213lineStart = lineSpan.Length > indentationLength

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxTreeExtensions.cs (4)

370return token.Span.Length == startDelimiterLength || 371(token.Span.Length > startDelimiterLength && endDelimiterLength < startDelimiterLength); 376return token.Span.Length == startDelimiterLength || 377(token.Span.Length > startDelimiterLength && token.Text[^1] != lastChar);

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

132var initialColumn = (token1.RawKind == 0) ? 0 : this.TreeInfo.GetOriginalColumn(Options.TabSize, token1) + token1.Span.Length;

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

62=> _root.FullSpan.Length;

Editor\TextEditApplication.cs (1)

42edit.Replace(change.Span.Start, change.Span.Length, change.NewText);

InlineRename\UI\Adornment\RenameFlyout.xaml.cs (1)

59RenameUserInput.SelectText(_viewModel.StartingSelection.Start, _viewModel.StartingSelection.Length);

Interactive\InteractiveDocumentNavigationService.cs (1)

55var snapshotSpan = new SnapshotSpan(textSnapshot, textSpan.Start, textSpan.Length);

Interactive\InteractiveWorkspace.cs (1)

51edit.Replace(change.Span.Start, change.Span.Length, change.NewText);

Interactive\SendToInteractiveSubmissionProvider.cs (1)

72Select(span => new SnapshotSpan(snapshot, span.Start, span.Length));

TextStructureNavigation\AbstractTextStructureNavigatorProvider.TextStructureNavigator.cs (1)

126if (node != null && activeSpan.Length == node.Value.Span.Length)

Classification\ClassificationTestHelper.cs (1)

54var text = actualText.Substring(actual.TextSpan.Start, actual.TextSpan.Length);

CompleteStatement\AbstractCompleteStatementTests.cs (1)

114view.Selection.Select(new SnapshotSpan(view.TextSnapshot, selectedSpan.Start, selectedSpan.Length), isReversed);

DocumentationComments\AbstractDocumentationCommentTests.cs (1)

153view.Selection.Select(new SnapshotSpan(view.TextSnapshot, selectedSpan.Start, selectedSpan.Length), isReversed);

KeywordHighlighting\AbstractKeywordHighlighterTests.cs (1)

58for (var i = 0; i <= cursorSpan.Length; i++)

Workspaces\EditorTestHostDocument.cs (2)

137_textView.Selection.Select(new SnapshotSpan(_textView.TextSnapshot, new Span(span.Start, span.Length)), false); 226edit.Replace(change.Span.Start, change.Span.Length, change.NewText);

Workspaces\EditorTestWorkspace.cs (3)

393var span = new Span(matchingSpan.Start, matchingSpan.Length); 413currentPositionInProjectionBuffer += matchingSpan.Length; 447var markupSpanEndExclusive = markupSpan.Start + markupSpan.Length;

Extensions.SnapshotSourceText.cs (1)

179var editorSpan = new Span(textSpan.Start, textSpan.Length);

Shared\Extensions\TextSpanExtensions.cs (2)

16=> new Span(textSpan.Start, textSpan.Length); 22=> new TextSpan(textSpan.Start + offset, textSpan.Length);

RenameTracking\RenameTrackingTaggerProviderTests.cs (5)

381state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "cation"); 395state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "Complex"); 409state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "Dog"); 429state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "_"); 853state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "Go");

Snippets\RoslynLSPSnippetConvertTests.cs (2)

492var textChange = new TextChange(new TextSpan(stringSpan.Start, 0), text.Substring(stringSpan.Start, stringSpan.Length)); 509var placeholderText = text.Substring(spans[0].Start, spans[0].Length);

BraceMatching\AbstractBraceMatcher.cs (1)

35where tok.Span.Length > 0

ClassifiedSpansAndHighlightSpanFactory.cs (1)

61length: narrowSpan.Length);

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.PragmaBatchFixHelpers.cs (3)

154var delta = textChange.NewText.Length - textChange.Span.Length; 161currentSpan = new TextSpan(newStart, currentSpan.Length); 167var newLength = currentSpan.Length + delta;

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.PragmaHelpers.cs (3)

45var spanChange = newStartToken.LeadingTrivia.FullSpan.Length - startToken.LeadingTrivia.FullSpan.Length; 46diagnosticSpan = new TextSpan(diagnosticSpan.Start + spanChange, diagnosticSpan.Length);

CodeLens\CodeLensReferencesService.cs (3)

143var referenceSpan = new TextSpan(spanStart, token.Span.Length); 155token.Span.Length, 163referenceSpan.Length,

Completion\Utilities.cs (2)

39var sumOfDeltas = changes.Sum(c => c.NewText!.Length - c.Span.Length); 40var totalNewSpan = new TextSpan(totalOldSpan.Start, totalOldSpan.Length + sumOfDeltas);

Copilot\ICopilotChangeAnalysisService.cs (1)

110totalDelta += newTextLength - change.Span.Length;

Debugging\DebugDataTipInfo.cs (1)

24=> Span.Length == 0 && Span.Start == 0 && Text == null;

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs (1)

283Debug.Assert(span.Value.Length < text.Length);

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (4)

168=> oldToken.RawKind == newToken.RawKind && oldToken.Span.Length == newToken.Span.Length && AreEquivalentImpl(oldToken, newToken); 1700if (TryGetActiveSpan(statement, statementPart, minLength: statement.Span.Length, out var span)) 6604Debug.Assert(otherNode.FullSpan.Length > 0);

EmbeddedLanguages\RegularExpressions\LanguageServices\RegexEmbeddedCompletionProvider.cs (1)

101properties.Add(KeyValuePair.Create(LengthKey, textChange.Span.Length.ToString()));

QuickInfo\IndentationHelper.cs (2)

62if (spanBeforeDeletion.Length > 0) 74if (span.Length > 0)

ReplaceDocCommentTextWithTag\AbstractReplaceDocCommentTextWithTagCodeRefactoringProvider.cs (1)

168if (span.Length != 0)

Snippets\RoslynLSPSnippetConverter.cs (1)

46for (var i = 0; i < textChange.Span.Length + 1;)

SolutionCrawler\AbstractDocumentDifferenceService.cs (3)

176var lengthDelta = range.NewLength - range.Span.Length; 178return (oldMember.Span.Length + lengthDelta) == newMember.Span.Length ? newMember : null;

SpellCheck\AbstractSpellCheckSpanService.cs (1)

60if (span.TextSpan.Length > 0)

src\Analyzers\Core\Analyzers\Formatting\AbstractFormattingAnalyzer.cs (1)

69var offset = change.Span.Length - change.NewText.Length;

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

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

TaskList\AbstractTaskListService.cs (1)

137var message = postfixLength == 0 ? fullString : fullString[..(fullSpan.Length - postfixLength)];

Wrapping\ChainedExpression\ChainedExpressionCodeActionComputer.cs (1)

142var position = _firstPeriodIndentationTrivia.FullSpan.Length + NormalizedWidth(firstChunk);

Wrapping\SeparatedSyntaxList\SeparatedSyntaxListCodeActionComputer.cs (3)

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

EditAndContinue\EditAndContinueTestVerifier.cs (1)

539.ThenByDescending(partners => partners.Key.Span.Length)

Features\UnifiedSuggestions\UnifiedSuggestedActionsSource.cs (1)

675if (selectionOpt?.Length > 0)

Handler\Breakpoints\ValidateBreakableRangeHandler.cs (1)

40if (span.Length > 0)

Handler\InlineCompletions\InlineCompletionsHandler.cs (4)

216var fieldInSnippetContext = GetTextSpanInContextOfSnippet(fieldInFormattedText.Start, spanContainingFormattedSnippet.Start, fieldInFormattedText.Length); 225var caretInSnippetContext = GetTextSpanInContextOfSnippet(caretInFormattedText.Start, spanContainingFormattedSnippet.Start, caretInFormattedText.Length); 237var amountToAdjust = textChangesBefore.Sum(t => t.NewText!.Length - t.Span.Length); 238return new TextSpan(originalSpan.Start + amountToAdjust, originalSpan.Length);

Handler\OnAutoInsert\OnAutoInsertHandler.cs (1)

216var amountToIndent = desiredCaretLinePosition.Character - lineToIndent.Span.Length;

Handler\SemanticTokens\SemanticTokensHelpers.cs (1)

223if (textSpan.Length > 0)

SemanticTokens\AbstractSemanticTokensTests.cs (1)

112var lineLength = text.Lines[currentLine].SpanIncludingLineBreak.Length;

SpellCheck\SpellCheckTests.cs (1)

556ranges[index++] = span.Length;

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

70bool OverlapsWithSpan(SyntaxNode n) => spansTree.HasIntervalThatOverlapsWith(n.FullSpan.Start, n.FullSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

373if (p.Length > 0 && char.IsLetter(name[p.Start])) 374return name.Substring(p.Start, p.Length).ToCamelCase();

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

147=> !spansTree.HasIntervalThatOverlapsWith(nodeOrToken.FullSpan.Start, nodeOrToken.FullSpan.Length);

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

Text\LargeTextTests.cs (2)

163Assert.Equal(length, textLine.Span.Length); 165Assert.Equal(length + newlineLength, textLine.SpanIncludingLineBreak.Length);

Text\SourceTextTests.cs (2)

48Assert.Equal(0, text.Lines[0].Span.Length); 449Assert.Equal(Text.Substring(span.Start, span.Length), writer.ToString());

Text\StringText_LineTest.cs (3)

86Assert.Equal(0, line.Span.Length); 87Assert.Equal(0, line.SpanIncludingLineBreak.Length); 100Assert.Equal(Environment.NewLine.Length, line.SpanIncludingLineBreak.Length);

Text\StringTextDecodingTests.cs (2)

246Assert.Equal(3, text.Lines[0].Span.Length); 276Assert.Equal(3, text.Lines[0].Span.Length);

Text\StringTextTest.cs (4)

48Assert.Equal(3, data.Lines[0].Span.Length); 63Assert.Equal(0, data.Lines[0].Span.Length); 116Assert.Equal(length, textLine.Span.Length); 118Assert.Equal(length + newlineLength, textLine.SpanIncludingLineBreak.Length);

Text\StringTextTests_Default.cs (2)

43Assert.Equal(0, data.Lines[0].Span.Length); 60Assert.Equal(3, data.Lines[0].Span.Length);

Text\TextChangeTests.cs (2)

102Assert.Equal(0, changes[0].Span.Length); 1005editedLength = editedLength - newChange.Span.Length + newChange.NewText.Length;

Text\TextSpanTest.cs (7)

23Assert.Equal(42, span.Length); 32Assert.Equal(40, span.Length); 44Assert.Equal(0, span.Length); 92Assert.Equal(0, span.Length); 103Assert.Equal(1, span.Length); 115Assert.Equal(1485, span.Length); 125Assert.Equal(int.MaxValue - 1, span.Length);

Analysis\FlowAnalysis\AbstractFlowPass.Regions.vb (1)

55If span.Length = 0 Then

GlobalImport.vb (1)

119Dim length = unmappedSpan.Length

Lowering\Instrumentation\CodeCoverageInstrumenter.vb (1)

550Return New Text.TextSpan(startSpan.Start, originalSpan.Length - (startSpan.Start - originalSpan.Start))

Scanner\Blender.vb (6)

96If span.Length = 0 Then 222_affectedRange = New TextChangeRange(span, span.Length - _change.Span.Length + _change.NewLength) 231Return position - _change.NewLength + _change.Span.Length 438Debug.Assert(_curNodeSpan.Length > 0) 439If _affectedRange.Span.Length = 0 Then

Scanner\Directives.vb (1)

546lengthSkipped += skippedSpan.Length

Scanner\Scanner.vb (1)

349Return SyntaxFactory.DisabledTextTrivia(GetTextNotInterned(span.Start, span.Length))

Symbols\Source\SourceMemberContainerTypeSymbol.vb (1)

3252aggregateLength += syntaxRef.Span.Length

Syntax\VisualBasicSyntaxTree.ParsedSyntaxTree.vb (1)

97Return _root.FullSpan.Length

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxTreeExtensions.vb (2)

233(token.Span.Length = startLength OrElse 234(token.Span.Length > startLength AndAlso Not token.ToString().EndsWith(lastChar, StringComparison.Ordinal)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Formatting\Engine\Trivia\TriviaDataFactory.TriviaRewriter.vb (1)

79Dim leading = SyntaxFactory.ParseLeadingTrivia(text.Substring(trailing.FullSpan.Length))

LineCommit\CommitCommandHandler.vb (1)

109Dim selectedSpan = New SnapshotSpan(snapshot, textspan.Start, textspan.Length)

Utilities\NavigationPointHelpers.vb (1)

63Dim totalLineSize = line.GetColumnFromLineOffset(line.Span.Length, indentSize)

Debugging\VisualBasicBreakpointService.vb (2)

66If span.Length = 0 Then 77Return GetBreakpointAsync(document, textSpan.Start, textSpan.Length, cancellationToken)

Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.vb (4)

120If _ignoredSpans IsNot Nothing AndAlso _ignoredSpans.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) Then 132If _ignoredSpans IsNot Nothing AndAlso _ignoredSpans.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) Then 144If _ignoredSpans IsNot Nothing AndAlso _ignoredSpans.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) Then 176If _ignoredSpans IsNot Nothing AndAlso _ignoredSpans.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) Then

EditAndContinue\BreakpointSpans.vb (1)

76If breakpointSpan.Value.Length >= minLength Then

EditAndContinue\VisualBasicEditAndContinueAnalyzer.vb (3)

128While node.Span.Length < span.Length AndAlso node.Parent.SpanStart = position 303Return BreakpointSpans.TryGetClosestBreakpointSpan(token.Parent, token.SpanStart, minLength:=token.Span.Length, span)

SplitOrMergeIfStatements\VisualBasicMergeConsecutiveIfStatementsCodeRefactoringProvider.vb (2)

29If span.Length = 0 OrElse 51If span.Length = 0 OrElse

SplitOrMergeIfStatements\VisualBasicMergeNestedIfStatementsCodeRefactoringProvider.vb (2)

29If span.Length = 0 OrElse 59If span.Length = 0 OrElse

EditAndContinue\BreakpointSpansTests.vb (3)

52Assert.True(breakpointSpan.Length = 0) 60source.Substring(expectedSpan.Value.Start, expectedSpan.Value.Length), 62source.Substring(breakpointSpan.Start, breakpointSpan.Length)))

Scanner\ScannerTests.vb (6)

1122Assert.Equal(3, tk.Span.Length) 1123Assert.Equal(4, tk.FullSpan.Length) 1129Assert.Equal(2, tk.Span.Length) 1130Assert.Equal(3, tk.FullSpan.Length) 1136Assert.Equal(2, tk.Span.Length) 1137Assert.Equal(3, tk.FullSpan.Length)

Syntax\SyntaxFactsTest.vb (1)

1022Dim builder As New System.Text.StringBuilder(cu.FullSpan.Length * 2)

TestSyntaxNodes.vb (19)

772Assert.Equal(5, keyword.Span.Length) 773Assert.Equal(6, keyword.FullSpan.Length) 784Assert.Equal(5, keyword.Span.Length) 785Assert.Equal(12, keyword.FullSpan.Length) 793Assert.Equal(7, keyword.Span.Length) 794Assert.Equal(8, keyword.FullSpan.Length) 804Assert.Equal(7, keyword.Span.Length) 805Assert.Equal(16, keyword.FullSpan.Length) 817Assert.Equal(7, endTry.Span.Length) 818Assert.Equal(8, endTry.FullSpan.Length) 924Assert.Equal(0, eof.Span.Length) 928Assert.Equal(0, endIfStmt.Span.Length) 991Assert.Equal(6, kwModule.Span.Length) 992Assert.Equal(7, kwModule.FullSpan.Length) 997Assert.Equal(6, kwModule.Span.Length) 998Assert.Equal(7, kwModule.FullSpan.Length) 1737Assert.Equal(0, tree.GetRoot().FindToken(node.FullSpan.Length - 1).TrailingTrivia.Count) 2188Assert.Equal(sN.FullWidth, cS.FullSpan.Length) 2189Assert.Equal(sN.Width, cS.Span.Length)

CompilationTestUtils.vb (5)

1012New String("~"c, Math.Max(Math.Min(sourceLocation.SourceSpan.Length, lineText.Length - offsetInLine + 1), 1)) + Environment.NewLine 1057If loc1.SourceSpan.Length < loc2.SourceSpan.Length Then Return -1 1058If loc1.SourceSpan.Length > loc2.SourceSpan.Length Then Return 1

ParserTestUtilities.vb (6)

385Assert.True(0 <> node.Span.Length OrElse node.Kind = SyntaxKind.CompilationUnit, "Unexpected 0 width node: " & node.Kind.ToString & node.Span.ToString) 622If spanLength IsNot Nothing AndAlso CInt(spanLength) <> syntaxErrorSpan.Length Then 797Assert.True(0 <> node.Span.Length, "Unexpected 0 width node: " & node.Kind().ToString & node.Span.ToString) 802Assert.True(0 <> node.Span.Length OrElse node.IsKind(SyntaxKind.EndOfFileToken) OrElse node.IsKind(SyntaxKind.StatementTerminatorToken) OrElse node.IsKind(SyntaxKind.ColonToken), "Unexpected 0 width token: " & node.Kind().ToString & node.Span.ToString) 804Assert.True(0 <> tr.Span.Length, "Unexpected 0 width trivia: " & node.Kind().ToString & node.Span.ToString) 810Assert.True(0 <> tr.Span.Length, "Unexpected 0 width trivia: " & node.Kind().ToString & node.Span.ToString)

CaseCorrection\VisualBasicCaseCorrectionService.vb (1)

49If span.Length <= s_threshold Then

Classification\Worker.vb (1)

85If span.Length <> 0 AndAlso _textSpan.OverlapsWith(span) Then

CodeCleanup\Providers\AbstractTokensCodeCleanupProvider.vb (1)

57_spans.GetIntervalsThatOverlapWith(node.FullSpan.Start, node.FullSpan.Length).Any()

CodeCleanup\Providers\AddMissingTokensCodeCleanupProvider.vb (3)

336_spans.HasIntervalThatContains(span.Start, span.Length) AndAlso 453If Not _spans.HasIntervalThatContains(span.Start, span.Length) Then 568Return node IsNot Nothing AndAlso node.Span.Length > 0

CodeCleanup\Providers\NormalizeModifiersOrOperatorsCodeCleanupProvider.vb (5)

93Not _spans.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) Then 203If Not _spans.HasIntervalThatContains(span.Start, span.Length) Then 243If Not _spans.HasIntervalThatContains(span.Start, span.Length) Then 272If Not _spans.HasIntervalThatContains(span.Start, span.Length) Then 455If Not _spans.HasIntervalThatContains(span.Start, span.Length) Then

Rename\VisualBasicRenameRewriterLanguageService.vb (3)

97newSpan = New TextSpan(oldSpan.Start, newSpan.Length) 237Me._renameSpansTracker.AddComplexifiedSpan(Me._documentId, oldSpan, New TextSpan(oldSpan.Start, newSpan.Length), Me._modifiedSubSpans) 295AddModifiedSpan(annotation.OriginalSpan, New TextSpan(token.Span.Start, newToken.Span.Length))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxTreeExtensions.vb (2)

233(token.Span.Length = startLength OrElse 234(token.Span.Length > startLength AndAlso Not token.ToString().EndsWith(lastChar, StringComparison.Ordinal)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Formatting\Engine\Trivia\TriviaDataFactory.TriviaRewriter.vb (1)

79Dim leading = SyntaxFactory.ParseLeadingTrivia(text.Substring(trailing.FullSpan.Length))

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

57Return _root.FullSpan.Length

Classification\ClassifierHelper.cs (2)

196if (span.TextSpan.Length == 0) 268syntacticPartSpan.Start, syntacticPartSpan.Length, ref tempBuffer.AsRef(),

Classification\IRemoteSemanticClassificationService.cs (1)

91classificationTriples.Add(textSpan.Length);

Classification\SyntaxClassification\AbstractSyntaxClassificationService.Worker.cs (1)

87if (textSpan.Length > 0 && textSpan.OverlapsWith(_textSpan))

Classification\SyntaxClassification\SyntacticChangeRangeComputer.cs (4)

161return newRoot.FullSpan.Length; 165return oldRoot.FullSpan.Length; 229return newRoot.FullSpan.Length; 233return oldRoot.FullSpan.Length;

CodeCleanup\AbstractCodeCleanerService.cs (2)

338var start = intervalTree.HasIntervalThatOverlapsWith(previousToken.SpanStart, previousToken.Span.Length) 343var end = intervalTree.HasIntervalThatOverlapsWith(nextToken.SpanStart, nextToken.Span.Length)

CodeFixes\FixAllOccurrences\TextChangeMerger.cs (2)

106change.Span.Start, change.Span.Length, ref overlappingSpans); 109change.Span.Start, change.Span.Length, ref intersectingSpans);

FindSymbols\FindReferences\FindReferenceCache.cs (1)

202if (span.Start == index && span.Length == text.Length && isMatch(text, token, args))

FindSymbols\SyntaxTree\SyntaxTreeIndex_Persistence.cs (1)

51writer.WriteInt32(span.Length);

FindSymbols\TopLevelSyntaxTree\DeclaredSymbolInfo.cs (1)

189writer.WriteInt32(Span.Length);

LinkedFileDiffMerging\LinkedFileDiffMergingSession.cs (4)

229currentPositionDelta += commentChangesList[commentChangeIndex].NewText!.Length - commentChangesList[commentChangeIndex].Span.Length; 237currentPositionDelta += mergedChange.NewText!.Length - mergedChange.Span.Length; 254currentPositionDelta += mergedChange.NewText!.Length - mergedChange.Span.Length; 263currentPositionDelta += commentChangesList[commentChangeIndex].NewText!.Length - commentChangesList[commentChangeIndex].Span.Length;

PatternMatching\AllLowerCamelCaseMatcher.cs (1)

157var maxCandidateHumpLength = candidateHump.Length;

PatternMatching\PatternMatcher.cs (8)

431if (patternPart.Length > candidatePart.Length) 438candidate, candidatePart.Start, patternPart.Length, 439pattern, patternPart.Start, patternPart.Length, compareOptions) == 0; 588matchSpans.Add(new TextSpan(candidateHump.Start, patternChunkCharacterSpan.Length)); 598candidateHump = new TextSpan(candidateHump.Start + patternChunkCharacterSpan.Length, candidateHump.Length - patternChunkCharacterSpan.Length);

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

902var length = renameLocation.Location.SourceSpan.Length;

Rename\ConflictEngine\RenamedSpansTracker.cs (4)

63adjustedStartingPosition += newSpan.Length - oldSpan.Length; 76adjustedStartingPosition += c.NewSpan.Length - c.OriginalSpan.Length;

Rename\RenameUtilities.cs (2)

268if (replaceInsideString.Substring(subSpan.Start, subSpan.Length) != matchText) 279startOffset += offset + subSpan.Length;

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (2)

375.Where(t => syntaxFactsService.IsStringLiteralOrInterpolatedStringLiteral(t) && t.Span.Length >= renameTextLength) 393.Where(t => t.Span.Length >= renameTextLength)

Shared\Extensions\FileLinePositionSpanExtensions.cs (4)

60startColumn = lines[startLine].SpanIncludingLineBreak.Length; 73endColumn = lines[endLine].SpanIncludingLineBreak.Length; 77startColumn = Math.Min(startColumn, lines[startLine].SpanIncludingLineBreak.Length); 78endColumn = Math.Min(endColumn, lines[endLine].SpanIncludingLineBreak.Length);

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

70bool OverlapsWithSpan(SyntaxNode n) => spansTree.HasIntervalThatOverlapsWith(n.FullSpan.Start, n.FullSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

373if (p.Length > 0 && char.IsLetter(name[p.Start])) 374return name.Substring(p.Start, p.Length).ToCamelCase();

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

147=> !spansTree.HasIntervalThatOverlapsWith(nodeOrToken.FullSpan.Start, nodeOrToken.FullSpan.Length);

Workspace\Solution\DocumentState.cs (1)

283if (change.Span.Length < MaxTextChangeRangeLength && change.NewLength < MaxTextChangeRangeLength)

SolutionTests\SolutionTests.cs (1)

3840Assert.Equal(newRoot.FullSpan.Length, tree3.Length);

ContractsCheckNameofFixProvider.cs (2)

92if (candidate.Span.Length < shortestSymbol) 95shortestSymbol = candidate.Span.Length;

ValueTracking\TreeItemViewModel.cs (1)

116var highlightSpan = new TextSpan(spanStartPosition, TextSpan.Length);

Venus\ContainedDocument.cs (1)

519var snippetInRightText = rightText.Substring(spanInRightText.Start, spanInRightText.Length);

Venus\ContainedDocument.DocumentServiceProvider.cs (2)

109if (primarySpan.Length != span.Length) 318=> new(targetSpan.Start - excerptSpan.Start, targetSpan.Length);

SemanticSearch\SemanticSearchToolWindowImpl.cs (1)

427var snapshotSpan = new SnapshotSpan(textSnapshot, textSpan.Start, textSpan.Length);

Client\RemoteLanguageServiceWorkspace.cs (1)

514edit.Replace(change.Span.Start, change.Span.Length, change.NewText);

Debugging\VisualBasicBreakpointResolutionServiceTests.vb (1)

30source.Substring(expectedSpan.Value.Start, expectedSpan.Value.Length),

Venus\DocumentService_IntegrationTests.vb (2)

327Return New ExcerptResult(mappedSource.GetSubText(line.Span), New TextSpan(mappedSpan.Start - line.Start, mappedSpan.Length), ImmutableArray.Create(New ClassifiedSpan(New TextSpan(0, line.Span.Length), ClassificationTypeNames.Text)), document, span)

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

70bool OverlapsWithSpan(SyntaxNode n) => spansTree.HasIntervalThatOverlapsWith(n.FullSpan.Start, n.FullSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

373if (p.Length > 0 && char.IsLetter(name[p.Start])) 374return name.Substring(p.Start, p.Length).ToCamelCase();

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

147=> !spansTree.HasIntervalThatOverlapsWith(nodeOrToken.FullSpan.Start, nodeOrToken.FullSpan.Length);

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

213lineStart = lineSpan.Length > indentationLength

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxTreeExtensions.cs (4)

370return token.Span.Length == startDelimiterLength || 371(token.Span.Length > startDelimiterLength && endDelimiterLength < startDelimiterLength); 376return token.Span.Length == startDelimiterLength || 377(token.Span.Length > startDelimiterLength && token.Text[^1] != lastChar);

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

132var initialColumn = (token1.RawKind == 0) ? 0 : this.TreeInfo.GetOriginalColumn(Options.TabSize, token1) + token1.Span.Length;

UpgradeToGeneratedRegexCodeFixer.cs (1)

140nodeToFix = root.FindNode(new TextSpan(nodeToFix.Span.Start + (typesModified * "partial".Length), nodeToFix.Span.Length), getInnermostNodeForTie: true);

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (10)

86currentNewEnd = currentNewEnd + newChange.NewLength - newChange.Span.Length; 150if (oldChange.Span.Length == 0 && oldChange.NewLength == 0) 224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion); 226oldChange = new TextChangeRange(new TextSpan(newChange.SpanStart - oldDelta, oldChange.Span.Length - oldChangeLeadingDeletion), oldChange.NewLength - oldChangeLeadingInsertion); 308oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 310var newDeletion = newChange.SpanLength + oldChange.Span.Length - oldChange.NewLength; 373oldDelta = oldDelta - oldChange.Span.Length + oldChange.NewLength; 391builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 430: this(range.Span.Start, range.Span.Length, range.NewLength)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

286if ((span2.Length == 0) || (span1.Start >= span2.End))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\TextSpanMutableIntervalTree.cs (2)

28=> this.HasIntervalThatIntersectsWith(span.Start, span.Length); 31=> this.HasIntervalThatOverlapsWith(span.Start, span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

177index += result[^1].Span.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequence.cs (2)

69public int Length => _span.Length; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length));

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

196=> node.Span.Length; 199=> node.FullSpan.Length; 424d = x.Length - y.Length; 555if (token.Span.Length > 0 && position <= token.Span.End) 585if (token.Span.Length > 0 && token.SpanStart <= position) 641if (token.Span.Length == 0) 680if (token.Span.Length == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTokenExtensions.cs (2)

53=> token.Span.Length; 56=> token.FullSpan.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTriviaExtensions.cs (2)

10=> trivia.Span.Length; 13=> trivia.FullSpan.Length;

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

412var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 542var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 600var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 629var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 651=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);

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

129currentNodeSpan.Length < resultSpan.Length)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormattingResult.cs (1)

83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (1)

59var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;

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

243for (; i < span.Length; i++) 252if (i == span.Length && text.Length == newText.Length) 260span = new TextSpan(span.Start + i, span.Length - i);

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

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (2)

18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

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

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

501for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

77words.Add(name.Substring(part.Start, part.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (2)

161Debug.Assert(spanToCheck.Length > 0); 178=> name.Substring(wordSpan.Start, wordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (3)

21Debug.Assert(nameSpan.Length > 0); 35if (Current.Length == 0) 74return Current.Length > 0 && Current.End <= _nameSpan.End;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

264WriteInteger(location.SourceSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (2)

194_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 195_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (2)

120_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 128result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));

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

30writer.WriteInt32(WordSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

70bool OverlapsWithSpan(SyntaxNode n) => spansTree.HasIntervalThatOverlapsWith(n.FullSpan.Start, n.FullSpan.Length);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

373if (p.Length > 0 && char.IsLetter(name[p.Start])) 374return name.Substring(p.Start, p.Length).ToCamelCase();

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

147=> !spansTree.HasIntervalThatOverlapsWith(nodeOrToken.FullSpan.Start, nodeOrToken.FullSpan.Length);