Length

Text\TextSpan.cs (1)

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)

169if (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; 797if (change.Span.Length == 0 && newTextLength == 0) 929newPosDelta += 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)

683properties = properties.Add(DefineDescriptorArgumentCorrectlyFixAdditionalDocumentLocationInfo, $"{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\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);

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;

Parser\LexerCache.cs (1)

192Debug.Assert(span.Length > 0);

Parser\SlidingTextWindow.cs (1)

207textSpan = _characterWindow.AsSpan(span.Start - _characterWindowStartPositionInText, span.Length);

Symbols\Source\SourceConstructorSymbolBase.cs (1)

206ctorInitializerLength = span.Length;

Symbols\Source\SourceMemberContainerSymbol.cs (2)

1128aggregateLength += syntaxRef.Span.Length; 1258return 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 (3)

213lineStart = lineSpan.Length > indentationLength 272index += charResults.Last().span.Length; 280index += charResults.Last().span.Length;

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;

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

121stack += token.Span.Length;

BlockCommentEditing\BlockCommentEditingCommandHandler.cs (1)

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

Formatting\CSharpFormattingInteractionService.cs (1)

85var span = textSpan ?? new TextSpan(0, parsedDocument.Root.FullSpan.Length);

Interactive\CSharpSendToInteractiveSubmissionProvider.cs (1)

125startToken = selectionSpan.Length == 0

RawStringLiteral\RawStringLiteralCommandHandler_TypeChar.cs (1)

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

StringCopyPaste\StringCopyPasteHelpers.cs (3)

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

Classification\SemanticClassifierTests_TestMarkup.cs (1)

105var actualFormatted = actualOrdered.SelectAsArray(a => new FormattedClassification(allCode.Substring(a.TextSpan.Start, a.TextSpan.Length), a.ClassificationType));

ExtractMethod\ExtractMethodMiscellaneousTests.cs (1)

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

EmbeddedLanguages\Json\CSharpJsonParserTests.cs (1)

239element.Add(new XAttribute("Length", d.Span.Length));

FlowAnalysis\RegionAnalysisTests.cs (1)

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

Semantics\RecordTests.cs (2)

566Assert.Equal(0, ctor.Parameters[1].Locations.Single().SourceSpan.Length); 594Assert.Equal(3, ctor.Parameters[1].Locations.Single().SourceSpan.Length);

BraceCompletion\AbstractCurlyBraceOrBracketCompletionService.cs (1)

211amountToShift += (newRange.NewLength - newRange.Span.Length);

BraceCompletion\ParenthesisBraceCompletionService.cs (1)

44if (closeParen.Kind() != SyntaxKind.CloseParenToken || closeParen.Span.Length == 0)

BraceCompletion\StringLiteralBraceCompletionService.cs (1)

75token.Span.Length > 1 &&

CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (1)

52if (textSpan.Length > 0)

Completion\CompletionProviders\DeclarationName\DeclarationNameRecommender.NameGenerator.cs (1)

85var text = baseName.Substring(@break.Start, @break.Length);

ConvertBetweenRegularAndVerbatimString\AbstractConvertBetweenRegularAndVerbatimStringCodeRefactoringProvider.cs (1)

179if (ch.Span.Length == 2 && ch.Rune.Value != 0)

ConvertToRawString\ConvertToRawStringHelpers.cs (3)

54if (ch.Span.Length > 1) 97if (ch.Span.Length > 1 && SyntaxFacts.IsNewLine((char)ch.Value)) 116if (ch.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)

577=> BreakpointSpans.TryGetClosestBreakpointSpan(token.Parent!, token.SpanStart, minLength: token.Span.Length, out span); 1822(commonForEachStatement.AwaitKeyword.Span.Length > 0) ? commonForEachStatement.AwaitKeyword.SpanStart : commonForEachStatement.ForEachKeyword.SpanStart, 1938=> (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))

Symbols\Source\LocationTests.cs (1)

48Assert.Equal(length, pos.SourceSpan.Length);

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)

10254Assert.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 (3)

213lineStart = lineSpan.Length > indentationLength 272index += charResults.Last().span.Length; 280index += charResults.Last().span.Length;

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\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\SyntaxTreeExtensions.cs (1)

121stack += token.Span.Length;

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

62=> _root.FullSpan.Length;

DocumentationComments\CopilotGenerateDocumentationCommentProvider.cs (1)

225var proposedEdit = new ProposedEdit(new SnapshotSpan(oldSnapshot, textSpan.Start, textSpan.Length),

Editor\TextEditApplication.cs (1)

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

Formatting\FormatCommandHandler.cs (1)

60LogType.UserAction, static (m, selectionOpt) => m["Span"] = selectionOpt?.Length ?? -1, selectionOpt), cancellationToken))

InlineRename\InlineRenameSession.OpenTextBufferManager.cs (1)

345edit.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));

Navigation\AbstractDefinitionLocationService.cs (1)

194if (position >= 0 && position < root.FullSpan.Length)

RenameTracking\RenameTrackingTaggerProvider.TrackingSession.cs (1)

179if (initialCheck && token.Span.Length != this.OriginalName.Length)

Structure\AbstractStructureTaggerProvider.cs (1)

261if (region.TextSpan.Length > 0)

TextStructureNavigation\AbstractTextStructureNavigatorProvider.TextStructureNavigator.cs (3)

92if (token.Span.Length == 0 && token.Span.Start == textLength) 95if (token.Span.Length > 0 && token.Span.Contains(position)) 126if (node != null && activeSpan.Length == node.Value.Span.Length)

BraceHighlighting\MultiCharacterBraceHighlightingTests.cs (2)

38Debug.Assert(text.Substring(braces.Value.LeftSpan.Start, braces.Value.LeftSpan.Length) == "<@"); 39Debug.Assert(text.Substring(braces.Value.RightSpan.Start, braces.Value.RightSpan.Length) == "@>");

Classification\AbstractClassifierTests.cs (1)

68var actualFormatted = actualOrdered.SelectAsArray(a => new FormattedClassification(allCode.Substring(a.TextSpan.Start, a.TextSpan.Length), a.ClassificationType));

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); 219edit.Replace(change.Span.Start, change.Span.Length, change.NewText);

Workspaces\EditorTestWorkspace.cs (3)

398var span = new Span(matchingSpan.Start, matchingSpan.Length); 418currentPositionInProjectionBuffer += matchingSpan.Length; 452var markupSpanEndExclusive = markupSpan.Start + markupSpan.Length;

Extensions.SnapshotSourceText.cs (1)

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

Shared\Extensions\TextSpanExtensions.cs (2)

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

EditorAdapter\SpanExtensionsTest.cs (1)

23Assert.Equal(length, 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), "_"); 844state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "Go");

Snippets\RoslynLSPSnippetConvertTests.cs (2)

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

Utilities\PatternMatcherTests.cs (1)

439result.Add(identifier.Substring(span.Start, span.Length));

Cohost\Handlers\DocumentSpellCheck.cs (1)

34razorSpans.Add(new SpellCheckSpan(span.TextSpan.Start, span.TextSpan.Length, kind));

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

139var referenceSpan = new TextSpan(spanStart, token.Span.Length); 152token.Span.Length, 158referenceSpan.Length, 262result.Span.Length, 288result.Span.Length, 310reference.Value.MappedSpan.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\CopilotUtilities.cs (1)

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

Copilot\ICopilotChangeAnalysisService.cs (1)

309codeFixCollection.TextSpan.Length,

Debugging\DebugDataTipInfo.cs (1)

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

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (4)

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

EmbeddedLanguages\Classification\AbstractFallbackEmbeddedLanguageClassifier.cs (1)

50if (vc.Span.Length > vc.Rune.Utf16SequenceLength)

EmbeddedLanguages\DateAndTime\DateAndTimeEmbeddedCompletionProvider.cs (1)

114properties.Add(new(LengthKey, textChange.Span.Length.ToString()));

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)

SemanticSearch\SemanticSearchDefinitionItemFactory.cs (3)

71displayParts: displaySpan.Length == span.Length ? [displayText] : [displayText, new TaggedText(TextTags.Punctuation, "…")], 78=> new(span.Start, Math.Min(span.Length, maxLength));

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

60if (span.TextSpan.Length > 0) 172seenEscape = seenEscape || endChar.Span.Length > 1; 176else if (endChar == ' ' && endChar.Span.Length == 1)

SplitOrMergeIfStatements\AbstractSplitIfStatementCodeRefactoringProvider.cs (1)

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

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

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

643if (selectionOpt?.Length > 0)

Handler\Breakpoints\ValidateBreakableRangeHandler.cs (1)

40if (span.Length > 0)

Handler\Formatting\AbstractFormatDocumentHandlerBase.cs (1)

37var rangeSpan = (range != null) ? ProtocolConversions.RangeToTextSpan(range, text) : new TextSpan(0, root.FullSpan.Length);

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

178if (desiredCaretLinePosition.Character > caretLine.Span.Length) 223var amountToIndent = desiredCaretLinePosition.Character - lineToIndent.Span.Length;

Handler\SemanticTokens\SemanticTokensHelpers.cs (2)

218if (textSpan.Length > 0) 325var tokenLength = originalTextSpan.Length;

Handler\SpellCheck\AbstractSpellCheckingHandler.cs (1)

192triples[triplesIndex++] = span.TextSpan.Length;

Handler\SpellCheck\SpellCheckPullCache.cs (1)

47writer.WriteInt32(span.TextSpan.Length);

SemanticTokens\AbstractSemanticTokensTests.cs (1)

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

SpellCheck\SpellCheckTests.cs (1)

588ranges[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);

Services\SemanticClassification\RemoteSemanticClassificationService.Caching.cs (1)

215writer.WriteCompressedUInt((uint)classifiedSpan.TextSpan.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

Classification\ClassifierHelper.cs (2)

199if (span.TextSpan.Length == 0) 271syntacticPartSpan.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)

885var 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)

377.Where(t => syntaxFactsService.IsStringLiteralOrInterpolatedStringLiteral(t) && t.Span.Length >= renameTextLength) 395.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)

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

SyntaxReferenceTests.cs (4)

59Assert.Equal(0, node.FullSpan.Length); 81Assert.Equal(0, node.FullSpan.Length); 155Assert.Equal(0, node.FullSpan.Length); 183Assert.Equal(0, node.Span.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 (2)

385var spanInOriginalText = new TextSpan(offsetInOriginalText + spanInLeftText.Start, spanInLeftText.Length); 519var snippetInRightText = rightText.Substring(spanInRightText.Start, spanInRightText.Length);

Venus\ContainedDocument.DocumentServiceProvider.cs (5)

109if (primarySpan.Length != span.Length) 237builder.Add(new ClassifiedSpan(new TextSpan(0, contentSpan.Length), ClassificationTypeNames.Text)); 242if (lastSpan.End < contentSpan.Length) 244builder.Add(new ClassifiedSpan(new TextSpan(lastSpan.End, contentSpan.Length - lastSpan.End), ClassificationTypeNames.Text)); 318=> new(targetSpan.Start - excerptSpan.Start, targetSpan.Length);

SemanticSearch\SemanticSearchToolWindowImpl.cs (1)

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

Client\RemoteLanguageServiceWorkspace.cs (1)

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

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

213lineStart = lineSpan.Length > indentationLength 272index += charResults.Last().span.Length; 280index += charResults.Last().span.Length;

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\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\SyntaxTreeExtensions.cs (1)

121stack += token.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);