1 write to Start
Microsoft.CodeAnalysis (1)
Text\TextSpan.cs (1)
34Start = start;
1990 references to Start
AnalyzerRunner (1)
DiagnosticAnalyzerRunner.cs (1)
207.ThenBy(tuple => tuple.Item2.Location.SourceSpan.Start)
Microsoft.CodeAnalysis (111)
Compilation\Compilation.cs (1)
3460MarkImportDirectiveAsUsed(node.SyntaxTree, node.Span.Start);
Diagnostic\SourceLocation.cs (1)
130return base.GetDebuggerDisplay() + "\"" + _syntaxTree.ToString().Substring(_span.Start, _span.Length) + "\"";
DiagnosticAnalyzer\AnalysisContextInfo.cs (2)
125var lastEnd = node.Span.Start; 129if (token.Span.Start - lastEnd > 0)
DiagnosticAnalyzer\AnalysisScope.cs (1)
98if (filterSpanOpt.GetValueOrDefault().Start == 0 && filterSpanOpt.GetValueOrDefault().Length == filterFile.GetValueOrDefault().SourceTree!.Length)
DiagnosticAnalyzer\AnalyzerDriver.cs (1)
2235syntaxTree.IsHiddenPosition(span.Start);
InternalUtilities\TextChangeRangeExtensions.cs (19)
37var currentStart = accumulatedTextChangeSoFar.Value.Span.Start; 39var currentNewEnd = accumulatedTextChangeSoFar.Value.Span.Start + accumulatedTextChangeSoFar.Value.NewLength; 68if (newChange.Span.Start < currentStart) 70currentStart = newChange.Span.Start; 96currentNewEnd = newChange.Span.Start + newChange.NewLength; 161else if (newChange.SpanEnd <= oldChange.Span.Start + oldDelta) 179else if (newChange.SpanStart < oldChange.Span.Start + oldDelta) 198var newChangeLeadingDeletion = oldChange.Span.Start + oldDelta - newChange.SpanStart; 200newChange = new UnadjustedNewChange(oldChange.Span.Start + oldDelta, newChange.SpanLength - newChangeLeadingDeletion, newChange.NewLength); 203else if (newChange.SpanStart > oldChange.Span.Start + oldDelta) 221var oldChangeLeadingInsertion = newChange.SpanStart - (oldChange.Span.Start + oldDelta); 224addAndAdjustOldDelta(builder, ref oldDelta, new TextChangeRange(new TextSpan(oldChange.Span.Start, oldChangeLeadingDeletion), oldChangeLeadingInsertion)); 231Debug.Assert(newChange.SpanStart == oldChange.Span.Start + oldDelta); 310newChange = new UnadjustedNewChange(oldChange.Span.Start + oldDelta, newDeletion, newChange.NewLength); 387if (last.Span.End == change.Span.Start) 390builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 393else if (last.Span.End > change.Span.Start) 429: this(range.Span.Start, range.Span.Length, range.NewLength) 434private static int NewEnd(this TextChangeRange range) => range.Span.Start + range.NewLength;
Syntax\LineDirectiveMap.cs (1)
51var unmappedStartPos = sourceText.Lines.GetLinePosition(span.Start);
Syntax\SyntaxDiffer.cs (8)
111int start = change.Range.Span.Start + delta; 577if (last.Range.Span.End == change.Range.Span.Start) 581new TextChangeRange(new TextSpan(last.Range.Span.Start, last.Range.Span.Length + change.Range.Span.Length), last.Range.NewLength + change.Range.NewLength), 587Debug.Assert(change.Range.Span.Start >= last.Range.Span.End); 598if (last.Range.Span.End == textChangeRange.Span.Start) 604new TextChangeRange(new TextSpan(last.Range.Span.Start, last.Range.Span.Length + textChangeRange.Span.Length), last.Range.NewLength + textChangeRange.NewLength), 610Debug.Assert(textChangeRange.Span.Start >= last.Range.Span.End); 763new TextSpan(range.Span.Start + commonLeadingCount, range.Span.Length - (commonLeadingCount + commonTrailingCount)),
Syntax\SyntaxList`1.cs (2)
135return TextSpan.FromBounds(this[0].FullSpan.Start, this[this.Count - 1].FullSpan.End); 153return TextSpan.FromBounds(this[0].Span.Start, this[this.Count - 1].Span.End);
Syntax\SyntaxNode.cs (3)
112/// Same as accessing <see cref="TextSpan.Start"/> on <see cref="Span"/>. 966var node = FindToken(span.Start, findInsideTrivia) 1530if (position < span.Start && token.HasLeadingTrivia)
Syntax\SyntaxNodeOrToken.cs (1)
245/// Same as accessing <see cref="TextSpan.Start"/> on <see cref="Span"/>.
Syntax\SyntaxToken.cs (1)
122/// Same as accessing <see cref="TextSpan.Start"/> on <see cref="Span"/>.
Syntax\SyntaxTree.cs (1)
270isHiddenPosition = GetLineVisibility(span.Start) == LineVisibility.Hidden;
Syntax\SyntaxTreeExtensions.cs (1)
67index += span.Start;
Syntax\SyntaxTrivia.cs (1)
101/// Same as accessing <see cref="TextSpan.Start"/> on <see cref="Span"/>.
Text\ChangedText.cs (9)
47if (change.Span.Start < position) 50if (change.Span.Start > oldText.Length) 296if (change.Span.Start > position) 305var lps = oldLineInfo.GetLinePositionSpan(TextSpan.FromBounds(position, change.Span.Start)); 311endsWithCR = oldText[change.Span.Start - 1] == '\r'; 315if (endsWithCR && change.Span.Start < oldText.Length && oldText[change.Span.Start] == '\n') 317lineStarts.Add(change.Span.Start + delta); 324var changeStart = change.Span.Start + delta;
Text\CompositeText.cs (1)
82var sourceIndex = span.Start;
Text\LargeText.cs (4)
183if (span.Start < 0 || span.Start > _length || span.End > _length) 196int chunkIndex = GetIndexFromPosition(span.Start); 197int chunkStartOffset = span.Start - _chunkStartOffsets[chunkIndex];
Text\SourceText.cs (10)
477Debug.Assert(0 <= span.Start && span.Start <= span.End); 497else if (spanLength == this.Length && span.Start == 0) 545int offset = span.Start; 618int position = Math.Max(Math.Min(span.Start, this.Length), 0); 662if (change.Span.Start < position) 667if (change.Span.End <= changeRanges.Last().Span.Start) 686if (change.Span.Start > position) 688var subText = this.GetSubText(new TextSpan(position, change.Span.Start - position)); 798var newPos = range.Span.Start + newPosDelta;
Text\StringBuilderText.cs (1)
85return _builder.ToString(span.Start, span.Length);
Text\StringText.cs (3)
78if (span.Start == 0 && span.Length == this.Length) 83return this.Source.Substring(span.Start, span.Length); 93if (span.Start == 0 && span.End == this.Length)
Text\SubText.cs (7)
23if (span.Start < 0 24|| span.Start >= text.Length 62return UnderlyingText[UnderlyingSpan.Start + position]; 70return UnderlyingText.ToString(GetCompositeSpan(span.Start, span.Length)); 77return new SubText(UnderlyingText, GetCompositeSpan(span.Start, span.Length)); 83UnderlyingText.CopyTo(span.Start, destination, destinationIndex, span.Length); 88int compositeStart = Math.Min(UnderlyingText.Length, UnderlyingSpan.Start + start);
Text\TextChange.cs (1)
107return $"new TextChange(new TextSpan({Span.Start}, {Span.Length}), {newTextDisplay})";
Text\TextChangeRange.cs (4)
28internal int NewEnd => Span.Start + NewLength; 109if (change.Span.Start < start) 111start = change.Span.Start; 134return $"new TextChangeRange(new TextSpan({Span.Start}, {Span.Length}), {NewLength})";
Text\TextLine.cs (7)
40if (span.Start > text.Length || span.Start < 0 || span.End > text.Length) 48if (span.Start > 0 && !TextUtilities.IsAnyLineBreakCharacter(text[span.Start - 1])) 54if (span.End > span.Start) 66span = new TextSpan(span.Start, span.Length + lineBreakLen); 76return new TextLine(text, span.Start, span.End);
Text\TextLineCollection.cs (1)
57return new LinePositionSpan(GetLinePosition(span.Start), GetLinePosition(span.End));
Text\TextSpan.cs (19)
47public int End => Start + Length; 72return unchecked((uint)(position - Start) < (uint)Length); 86return span.Start >= Start && span.End <= this.End; 102int overlapStart = Math.Max(Start, span.Start); 119int overlapStart = Math.Max(Start, span.Start); 140return span.Start <= this.End && span.End >= Start; 156return unchecked((uint)(position - Start) <= (uint)Length); 170int intersectStart = Math.Max(Start, span.Start); 221return Start == other.Start && Length == other.Length; 235return Hash.Combine(Start, Length); 245return $"[{Start}..{End})"; 253var diff = Start - other.Start;
Microsoft.CodeAnalysis.CodeStyle (178)
AbstractFileBannerFacts.cs (3)
154(node.FullSpan.Start == 0 && _fileBannerMatcher.TryMatch(leadingTriviaToKeep, ref index))) 166Debug.Assert(root.FullSpan.Start == 0); 172Debug.Assert(firstToken.FullSpan.Start == 0);
AbstractFileHeaderHelper.cs (2)
71fileHeaderStart = Math.Min(trivia.FullSpan.Start, fileHeaderStart); 94fileHeaderStart = trivia.FullSpan.Start;
AbstractFormattingResult.cs (2)
83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);
AbstractHeaderFacts.cs (3)
59if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 81if (tokenToRightOrIn.FullSpan.Start != position && tokenToRightOrIn.RawKind != SyntaxFacts.SyntaxKinds.EndOfFileToken) 97return Math.Min(afterAttributesToken.Span.Start, node.Span.End);
AbstractIndentation.Indenter.cs (1)
248=> Math.Min(Root.EndOfFileToken.FullSpan.Start, position);
AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (3)
102textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 110textSpan = TextSpan.FromBounds(previous.Value.textSpan.Start, nodeEnd); 116textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd);
AbstractRemoveUnnecessaryParenthesesDiagnosticAnalyzer.cs (2)
133var expressionFirstLine = lines.GetLineFromPosition(parenthesizedExpressionLocation.SourceSpan.Start); 136return Location.Create(parenthesizedExpression.SyntaxTree, TextSpan.FromBounds(parenthesizedExpressionLocation.SourceSpan.Start, textSpanEndPosition));
AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (1)
562if (pragma.Span.End <= diagnostic.Location.SourceSpan.Start)
AbstractSelectedMembers.cs (3)
66? root.FindToken(textSpan.Start) 67: root.FindTokenOnRightOfPosition(textSpan.Start); 126var position = textSpan.Start;
AbstractSimplifyInterpolationHelpers.cs (2)
49.OrderBy(t => t.Start) 188: TextSpan.FromBounds(sequence.First().Span.Start, sequence.Last().Span.End);
AbstractTriviaFormatter.cs (5)
488if (ContainsOnlyWhitespace(firstToken.FullSpan.Start, firstToken.SpanStart)) 502for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++) 836return TextSpan.FromBounds(this.StartPosition, trivia2.FullSpan.Start); 844return TextSpan.FromBounds(trivia1.FullSpan.End, trivia2.FullSpan.Start); 938var offset = trivia.FullSpan.Start - this.StartPosition;
AbstractVirtualCharService.cs (5)
86Debug.Assert(currentVC.Span.Start >= token.SpanStart, "First span has to start after the start of the string token"); 90Debug.Assert(currentVC.Span.Start == token.SpanStart + 1 || 91currentVC.Span.Start == token.SpanStart + 2, "First span should start on the second or third char of the string."); 99Debug.Assert(currentVC.Span.End <= nextVC.Span.Start, "Virtual character spans have to be ordered."); 108Debug.Assert(currentVC.Span.End == nextVC.Span.Start, "Virtual character spans have to be touching.");
AnchorIndentationOperation.cs (1)
19Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);
BaseIndentationFormattingRule.cs (9)
131=> TextSpan.FromBounds(Math.Max(_span.Start, textSpan.Start), Math.Min(_span.End, textSpan.End)); 152token1 = root.FindToken(span.Start); 157if (span.End < token1.Span.Start) 162if (token2.Span.End < span.Start) 177if (span.Start <= token1.Span.Start) 190var end = token2.Span.Start; 196end = token2.Span.Start;
BKTree.Builder.cs (2)
195_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 196_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));
BKTree.cs (2)
124_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 130result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));
BKTree.Node.cs (1)
36writer.WriteInt32(WordSpan.Start);
BottomUpBaseIndentationFinder.cs (2)
59if (token.Span.End <= operation.TextSpan.Start && 337if (operation.TextSpan.IsEmpty && operation.TextSpan.Start == position)
CommonFormattingHelpers.cs (13)
20return o1.TextSpan.Start - o2.TextSpan.Start; 26var s = o1.TextSpan.Start - o2.TextSpan.Start; 83var startToken = root.FindToken(textSpan.Start); 93if (textSpan.Start < startToken.SpanStart) 139return root.FullSpan.End == startToken.SpanStart || startToken.FullSpan.End > endToken.FullSpan.Start; 181if (token1.FullSpan.End == token2.FullSpan.Start) 189for (var token = token1.GetNextToken(includeZeroWidth: true); token.FullSpan.End <= token2.FullSpan.Start; token = token.GetNextToken(includeZeroWidth: true)) 300var forwardPosition = token.FullSpan.Start; 308Contract.ThrowIfFalse(parentNode.FullSpan.Start < forwardPosition); 324if (fullSpan.Start < position) 364var startToken = root.FindToken(span.Start).GetPreviousToken();
EditorConfigFile.cs (2)
47.ThenByDescending(x => x.section.Span.Start) 85.ThenByDescending(x => x.section.Span.Start) // in event of a further tie, pick entry at the bottom of the file
EmbeddedSyntaxHelpers.cs (1)
19=> TextSpan.FromBounds(firstChar.Span.Start, lastChar.Span.End);
EmbeddedSyntaxNode.cs (2)
85return span.Value.Start; 118start = Math.Min(token.VirtualChars[0].Span.Start, start);
EmbeddedSyntaxToken.cs (3)
82Math.Min(LeadingTrivia.Length == 0 ? int.MaxValue : LeadingTrivia[0].GetSpan().Start, 83Math.Min(VirtualChars.Length == 0 ? int.MaxValue : VirtualChars[0].Span.Start, 84TrailingTrivia.Length == 0 ? int.MaxValue : TrailingTrivia[0].GetSpan().Start));
FormattingAnalyzerHelper.cs (4)
41if (oldText.GetSubText(new TextSpan(change.Span.Start + offset, change.NewText.Length)).ContentEquals(SourceText.From(change.NewText))) 43change = new TextChange(new TextSpan(change.Span.Start, offset), ""); 50if (oldText.GetSubText(new TextSpan(change.Span.Start, change.NewText.Length)).ContentEquals(SourceText.From(change.NewText))) 52change = new TextChange(new TextSpan(change.Span.Start + change.NewText.Length, offset), "");
FormattingContext.AnchorData.cs (3)
44=> value.TextSpan.Start; 50=> value.TextSpan.Start; 56=> value.InseparableRegionSpan.Start;
FormattingContext.cs (12)
162if (operationSpan.Start < baseSpan.Start || 208var inseparableRegionStartingPosition = effectiveBaseTokenGetter(this, operation).FullSpan.Start; 227var indentationData = _indentationTree.GetSmallestContainingInterval(operation.TextSpan.Start, 0); 436var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 473var indentationData = _relativeIndentationTree.GetSmallestContainingInterval(span.Start, 0); 495var anchorData = _anchorTree.GetSmallestContainingInterval(span.Start, 0); 499DebugCheckEmpty(_anchorTree, new TextSpan(span.Start, 0)); 566var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 624var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 653var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 675=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);
FormattingContext.IndentationData.cs (1)
120return new RelativeIndentationData(_formattingContext, InseparableRegionSpan.Start, span, Operation, _effectiveBaseTokenGetter, _indentationDeltaGetter, _baseIndentationGetter, _lazyIndentationDelta);
FormattingExtensions.cs (2)
278span = new TextSpan(span.Start + i, span.Length - i); 340last = TextSpan.FromBounds(last.Start, span.End);
IndentBlockOperation.cs (3)
19Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 39Contract.ThrowIfFalse(baseToken.Span.End <= textSpan.Start); 41Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);
ISyntaxFactsExtensions.cs (2)
166var span = TextSpan.FromBounds(nodes.First().Span.Start, nodes.Last().Span.End); 461var startOfNodeWithoutAttributes = Math.Min(afterAttributesToken.Span.Start, endOfNode);
J\s\src\Compilers\Core\Portable\Syntax\SyntaxTreeExtensions.cs\SyntaxTreeExtensions.cs (1)
67index += span.Start;
J\s\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTreeExtensions.cs\SyntaxTreeExtensions.cs (1)
103var startLineNumber = text.Lines.IndexOf(span.Start);
LocationExtensions.cs (2)
20=> location.GetSourceTreeOrThrow().GetRoot(cancellationToken).FindToken(location.SourceSpan.Start); 39return !(tree == null || tree.IsHiddenPosition(loc.SourceSpan.Start));
NamingStyle.cs (8)
177=> name.Substring(wordSpan.Start, wordSpan.Length); 179private static readonly Func<string, TextSpan, bool> s_firstCharIsLowerCase = (val, span) => !DoesCharacterHaveCasing(val[span.Start]) || char.IsLower(val[span.Start]); 180private static readonly Func<string, TextSpan, bool> s_firstCharIsUpperCase = (val, span) => !DoesCharacterHaveCasing(val[span.Start]) || char.IsUpper(val[span.Start]); 184for (int i = span.Start, n = span.End; i < n; i++) 197for (int i = span.Start, n = span.End; i < n; i++) 410newWords[i] = name[parts[i].Start..parts[i].End];
NamingStyle.WordSpanEnumerator.cs (1)
27Current = new TextSpan(nameSpan.Start, 0);
NormalizedTextSpanCollection.cs (17)
96if (span1.Start < span2.Start) 286if ((span2.Length == 0) || (span1.Start >= span2.End)) 290else if (span1.End <= span2.Start) 296spans.Add(TextSpan.FromBounds(Math.Max(lastEnd, span1.Start), span1.End)); 302if (span1.Start < span2.Start) 306Debug.Assert(lastEnd < span2.Start); 307spans.Add(TextSpan.FromBounds(Math.Max(lastEnd, span1.Start), span2.Start)); 334spans.Add(TextSpan.FromBounds(Math.Max(lastEnd, span1.Start), span1.End)); 564if (end < span.Start) 574start = span.Start; 597sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); }); 601var oldStart = sorted[0].Start; 605var newStart = sorted[i].Start;
SimpleIntervalTreeExtensions.cs (1)
16=> tree.HasIntervalThatIntersectsWith(span.Start, span.Length);
SimplifyTypeNamesDiagnosticAnalyzerBase.cs (1)
258if (intervalTree.HasIntervalThatOverlapsWith(span.Start, span.End))
SourceTextExtensions_SharedWithCodeStyle.cs (1)
48var startLineNumber = text.Lines.IndexOf(span.Start);
StringBreaker.cs (1)
33Debug.Assert(span.Start >= start, "Bad generator.");
SuppressIntervalIntrospector.cs (2)
14=> value.TextSpan.Start; 20=> value.TextSpan.Start;
SuppressOperation.cs (1)
17Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);
SymbolKey.SymbolKeyWriter.cs (1)
258WriteInteger(location.SourceSpan.Start);
SyntaxNodeExtensions.cs (2)
322Math.Min(fullSpan.Start, node.SpanStart), 689while (position <= token.SpanStart && root.FullSpan.Start < token.SpanStart);
TextChangeRangeExtensions.cs (19)
37var currentStart = accumulatedTextChangeSoFar.Value.Span.Start; 39var currentNewEnd = accumulatedTextChangeSoFar.Value.Span.Start + accumulatedTextChangeSoFar.Value.NewLength; 68if (newChange.Span.Start < currentStart) 70currentStart = newChange.Span.Start; 96currentNewEnd = newChange.Span.Start + newChange.NewLength; 161else if (newChange.SpanEnd <= oldChange.Span.Start + oldDelta) 179else if (newChange.SpanStart < oldChange.Span.Start + oldDelta) 198var newChangeLeadingDeletion = oldChange.Span.Start + oldDelta - newChange.SpanStart; 200newChange = new UnadjustedNewChange(oldChange.Span.Start + oldDelta, newChange.SpanLength - newChangeLeadingDeletion, newChange.NewLength); 203else if (newChange.SpanStart > oldChange.Span.Start + oldDelta) 221var oldChangeLeadingInsertion = newChange.SpanStart - (oldChange.Span.Start + oldDelta); 224addAndAdjustOldDelta(builder, ref oldDelta, new TextChangeRange(new TextSpan(oldChange.Span.Start, oldChangeLeadingDeletion), oldChangeLeadingInsertion)); 231Debug.Assert(newChange.SpanStart == oldChange.Span.Start + oldDelta); 310newChange = new UnadjustedNewChange(oldChange.Span.Start + oldDelta, newDeletion, newChange.NewLength); 387if (last.Span.End == change.Span.Start) 390builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 393else if (last.Span.End > change.Span.Start) 429: this(range.Span.Start, range.Span.Length, range.NewLength) 434private static int NewEnd(this TextChangeRange range) => range.Span.Start + range.NewLength;
TextLineExtensions.cs (1)
71for (var i = line.Span.Start; i < line.Span.End; i++)
TextSpanExtensions.cs (8)
31if (span.Start < start) 33start = span.Start; 62var innerSpan = TextSpan.FromBounds(startNode.Span.Start, endNode.Span.End); 63var outerSpan = TextSpan.FromBounds(startNode.FullSpan.Start, endNode.FullSpan.End); 79var startSegmentEnd = Math.Min(span.End, except.Start); 80if (span.Start < startSegmentEnd) 81yield return TextSpan.FromBounds(span.Start, startSegmentEnd); 83var endSegmentStart = Math.Max(span.Start, except.End);
TextSpanIntervalIntrospector.cs (1)
12=> value.Start;
TokenStream.cs (1)
87Debug.Assert(previousToken.FullSpan.End <= currentToken.FullSpan.Start);
TreeData.cs (1)
62get { return this.Root.FullSpan.Start; }
TreeData.NodeAndText.cs (1)
38return _text.ToString(TextSpan.FromBounds(token2.FullSpan.Start, token2.SpanStart));
TreeData.StructuredTrivia.cs (1)
43var text = _trivia.ToFullString()[..(token.SpanStart - _trivia.FullSpan.Start)];
VirtualCharSequence.Chunks.cs (2)
52if (position < _array[0].Span.Start || position >= _array[^1].Span.End) 57if (position < ch.Span.Start)
VirtualCharSequence.cs (6)
56if (span.Start > sequence.Length) 74public VirtualChar this[int index] => _leafCharacters[_span.Start + index]; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length)); 197Debug.Assert(_span.End == virtualChars._span.Start); 211TextSpan.FromBounds(chars1._span.Start, chars2._span.End));
Microsoft.CodeAnalysis.CodeStyle.Fixes (23)
AbstractCodeGenerationService.cs (3)
506positionOfRemovedNode = attributeList.FullSpan.Start; 526positionOfRemovedNode = attributeToRemove.FullSpan.Start; 528var previousToken = root.FindToken(attributeToRemove.FullSpan.Start - 1);
AbstractConflictMarkerCodeFixProvider.cs (4)
75var position = context.Span.Start; 389(d1, d2) => d1.Location.SourceSpan.Start - d2.Location.SourceSpan.Start).ToImmutableArray(); 402var position = diagnostic.Location.SourceSpan.Start;
AbstractConvertToAsyncCodeFixProvider.cs (1)
51var ancestors = root.FindToken(span.Start).GetAncestors<SyntaxNode>();
AbstractIteratorCodeFixProvider.cs (1)
47var ancestors = root.FindToken(span.Start).GetAncestors<SyntaxNode>();
AbstractMoveDeclarationNearReferenceService.State.cs (1)
107let token = syntaxRoot.FindToken(r.Location.SourceSpan.Start)
AbstractMultipleBlankLinesCodeFixProvider.cs (1)
57var token = root.FindToken(diagnostic.AdditionalLocations[0].SourceSpan.Start);
AbstractRemoveAsyncModifierCodeFixProvider.cs (1)
75foreach (var diagnostic in diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start))
AbstractRemoveUnusedValuesCodeFixProvider.cs (3)
257return diagnostics.GroupBy(d => syntaxFacts.GetContainingMemberDeclaration(root, d.Location.SourceSpan.Start) ?? root); 351diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start), 361diagnostics.OrderBy(d => d.Location.SourceSpan.Start),
AbstractUseIsNullForReferenceEqualsCodeFixProvider.cs (1)
59foreach (var diagnostic in diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start))
CodeGenerationHelpers.cs (1)
206var afterMember = declarationList.LastOrDefault(m => m.SpanStart <= info.Context.AfterThisLocation.SourceSpan.Start);
DocumentExtensions.cs (1)
119var token = root.FindToken(span.Start);
RemoveUnnecessaryPragmaSuppressionsCodeFixProvider.cs (2)
44root.FindTrivia(diagnostic.Location.SourceSpan.Start).HasStructure) 89node = editor.OriginalRoot.FindTrivia(location.SourceSpan.Start).GetStructure()!;
SimplifyConditionalCodeFixProvider.cs (1)
58diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start).ToImmutableArray(),
SyntaxEditorBasedCodeFixProvider.cs (2)
45.Sort((d1, d2) => d1.Location.SourceSpan.Start - d2.Location.SourceSpan.Start);
Microsoft.CodeAnalysis.CodeStyle.LegacyTestFramework.UnitTestUtilities (2)
AbstractCodeActionOrUserDiagnosticTest.cs (2)
482.OrderBy(location => location.SourceSpan.Start) 533segments.Add((documentOffset + diagnostic.Location.SourceSpan.Start, "{|" + markupKey + ":"));
Microsoft.CodeAnalysis.CSharp (66)
Binder\Binder_Expressions.cs (1)
2026return node.SpanStart < localSymbolLocation.SourceSpan.Start;
Binder\Binder_Symbols.cs (2)
1851if (containerResult == 0 && la.SourceTree == lb.SourceTree) return lb.SourceSpan.Start - la.SourceSpan.Start;
Binder\BinderFactory.BinderFactoryVisitor.cs (1)
1051else if (_position < containingSpan.Start || _position > containingSpan.End) //NB: > not >=
Binder\Imports.cs (1)
53UsingAliases.OrderBy(x => x.Value.UsingDirective.Location.SourceSpan.Start).Select(ua => $"{ua.Key} = {ua.Value.Alias.Target}").Concat(
Binder\LocalScopeBinder.cs (2)
467if (declaredInThisScope && newLocation.SourceSpan.Start >= local.Locations[0].SourceSpan.Start)
Compilation\CSharpCompilation.cs (9)
2400if (!this.IsImportDirectiveUsed(infoTree, infoSpan.Start)) 2419var node = info.Tree.GetRoot(cancellationToken).FindToken(info.Span.Start, findInsideTrivia: false). 2550return Hash.Combine(Tree, Span.Start); 4238return loc1.SourceSpan.Start - loc2.SourceSpan.Start; 4249return loc1.Span.Start - loc2.Span.Start; 4260return loc1.Span.Start - loc2.Span.Start;
Compilation\CSharpDiagnosticFilter.cs (1)
147var position = location.SourceSpan.Start;
Compilation\CSharpSemanticModel.cs (2)
1330Debug.Assert(position == fullSpan.Start); 2206var binder = this.GetEnclosingBinder(boundExpr.Syntax.Span.Start);
Compilation\SyntaxTreeSemanticModel.cs (2)
1781if (loc.SourceSpan.IsEmpty && loc.SourceSpan.End == declarationSpan.Start) 2396var position = CheckAndAdjustPosition(location.SourceSpan.Start);
FlowAnalysis\AbstractFlowPass.cs (1)
303return RegionSpan.Contains(span.Start);
FlowAnalysis\ControlFlowPass.cs (3)
342var sourceStart = sourceLocation.SourceSpan.Start; 343var targetStart = node.Label.Locations[0].SourceSpan.Start; 347var usingStart = usingDecl.symbol.Locations[0].SourceSpan.Start;
FlowAnalysis\DefiniteAssignment.cs (1)
1173(symbol.Locations.Length == 0 || node.Span.End < symbol.Locations.FirstOrNone().SourceSpan.Start))
Lowering\Instrumentation\CodeCoverageInstrumenter.cs (3)
631return new TextSpan(startSpan.Start, originalSpan.Length - (startSpan.Start - originalSpan.Start));
Lowering\Instrumentation\DebugInfoInjector.cs (1)
249? TextSpan.FromBounds(forEachSyntax.AwaitKeyword.Span.Start, forEachSyntax.ForEachKeyword.Span.End)
Lowering\Instrumentation\DebugInfoInjector_SequencePoints.cs (1)
42int start = usingSyntax.Span.Start;
Lowering\LocalRewriter\LocalRewriter_SwitchExpression.cs (1)
76var spanStart = syntax.SwitchKeyword.Span.Start;
Parser\Blender.cs (2)
128var start = Math.Max(Math.Min(changeRange.Span.Start, lastCharIndex), 0); 159var finalLength = changeRange.NewLength + (changeRange.Span.Start - start);
Symbols\LexicalSortKey.cs (2)
68: this(syntaxRef.SyntaxTree, syntaxRef.Span.Start, compilation) 75: this((SyntaxTree)location.SourceTree, location.SourceSpan.Start, compilation)
Symbols\RangeVariableSymbol.cs (1)
64SyntaxToken token = (SyntaxToken)_locations[0].SourceTree.GetRoot().FindToken(_locations[0].SourceSpan.Start);
Symbols\Source\SourceConstructorSymbol.cs (2)
194offset = position - ctorSyntax.Body.Span.Start; 199offset = position - ctorSyntax.ExpressionBody.Span.Start;
Symbols\Source\SourceConstructorSymbolBase.cs (1)
225return -ctorInitializerLength + (position - span.Start);
Symbols\Source\SourceMemberContainerSymbol.cs (9)
1097if (declaration.Declarations.Length >= 1 && position == declaration.Declarations[0].Location.SourceSpan.Start) 1133int distanceFromInitializerStart = position - initializer.Syntax.Span.Start; 1225int index = initializers.BinarySearch(position, (initializer, pos) => initializer.Syntax.Span.Start.CompareTo(pos)); 2917Debug.Assert(declaredMembers.DeclarationWithParameters.Span.Contains(InstanceInitializersForPositionalMembers[0].Syntax.Span.Start)); 2943declaredMembers.DeclarationWithParameters.Span.Contains(declaredMembers.InstanceInitializers[insertAt][0].Syntax.Span.Start)) 2951Debug.Assert(insertedInitializers[insertedInitializers.Count - 1].Syntax.Span.Start < declaredInitializers[0].Syntax.Span.Start); 2965declaredMembers.DeclarationWithParameters.Span.Contains(g[0].Syntax.Span.Start))); 3758Debug.Assert(node.SpanStart > initializers.Last().Syntax.Span.Start);
Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (2)
1720if (GetImplementsLocationOrFallback(interface1).SourceSpan.Start > GetImplementsLocationOrFallback(interface2).SourceSpan.Start)
Symbols\Symbol.cs (1)
381SyntaxToken token = location.SourceTree.GetRoot().FindToken(location.SourceSpan.Start);
Syntax\CSharpLineDirectiveMap.cs (1)
225var unmappedStartPos = lines.GetLinePosition(span.Start);
Syntax\CSharpSyntaxTree.cs (1)
647=> new(FilePath, GetLinePosition(span.Start, cancellationToken), GetLinePosition(span.End, cancellationToken));
Syntax\NullableContextStateMap.cs (2)
106int index = GetContextStateIndex(span.Start); 108Debug.Assert(context.Position <= span.Start);
Syntax\SyntaxNodeRemover.cs (8)
70int start = span0.Start; 76start = Math.Min(start, span.Start); 344var span = TextSpan.FromBounds(token.Span.Start, node.Span.End); 345var fullSpan = TextSpan.FromBounds(token.FullSpan.Start, node.FullSpan.End); 378var span = TextSpan.FromBounds(node.Span.Start, token.Span.End); 379var fullSpan = TextSpan.FromBounds(node.FullSpan.Start, token.FullSpan.End); 410removedSpan = TextSpan.FromBounds(span.Start, removedSpan.End); 415removedSpan = TextSpan.FromBounds(removedSpan.Start, span.End);
Syntax\SyntaxReplacer.cs (2)
142start = span.Start; 148start = Math.Min(start, span.Start);
Microsoft.CodeAnalysis.CSharp.CodeStyle (37)
CSharpAddBracesDiagnosticAnalyzer.cs (1)
131var ifStatementSpanWithoutElse = TextSpan.FromBounds(statement.Span.Start, embeddedStatement.Span.End);
CSharpInlineDeclarationDiagnosticAnalyzer.cs (3)
329var localStatementStart = localStatement.Span.Start; 330var argumentNodeStart = argumentNode.Span.Start; 338var descendentStart = descendentNode.Span.Start;
CSharpRemoveUnnecessaryNullableDirectiveDiagnosticAnalyzer.cs (1)
236if (IntervalTree.HasIntervalThatOverlapsWith(span.Start, span.End))
CSharpRemoveUnreachableCodeDiagnosticAnalyzer.cs (2)
79firstUnreachableStatement.SpanStart != sourceSpan.Start) 125var span = TextSpan.FromBounds(section[0].FullSpan.Start, section.Last().FullSpan.End);
CSharpSyntaxFacts.cs (1)
1123return !branch.IsActive || !branch.BranchTaken ? TextSpan.FromBounds(branch.FullSpan.Start, position) : default;
CSharpUseLocalFunctionDiagnosticAnalyzer.cs (1)
212var descendentStart = descendentNode.Span.Start;
CSharpVirtualCharService.cs (3)
206var lineStart = lineSpan.Start; 213? lineSpan.Start + indentationLength 315runeResults.Add(VirtualChar.Create(rune, TextSpan.FromBounds(span.Start, nextSpan.End)));
IndentBlockFormattingRule.cs (2)
129span = lastSection ? span : TextSpan.FromBounds(span.Start, endToken.FullSpan.End); 346AddIndentBlockOperation(list, firstToken, lastToken, TextSpan.FromBounds(firstToken.FullSpan.Start, lastToken.FullSpan.End));
InvokeDelegateWithConditionalAccessAnalyzer.cs (2)
200if (nextToken.Span.Start < ifStatement.Span.End) 202fadeLocation = Location.Create(tree, TextSpan.FromBounds(nextToken.Span.Start, ifStatement.Span.End));
J\s\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxTreeExtensions.cs\SyntaxTreeExtensions.cs (13)
56positionBeforeModifiers = token.FullSpan.Start; 63positionBeforeModifiers = token.FullSpan.Start; 70positionBeforeModifiers = token.FullSpan.Start; 245if (position > fullSpan.Start && position < fullSpan.End) 252if (position > fullSpan.Start && position <= fullSpan.End) 271if (position > span.Start && position < span.End) 290? position > span.Start && position < span.End 291: position > span.Start && position <= span.End; 326if (position > span.Start && position <= span.End) 352if (position > span.Start && position <= span.End) 388for (int i = token.Span.End - 1, n = token.Span.Start; i >= n; i--) 440return (position > span.Start && position < span.End) 479return (position > span.Start && position < span.End)
SyntaxNodeExtensions.cs (2)
641if (!textSpan.Contains(matchSpan.Start)) 797if (position < span.Start)
SyntaxTriviaExtensions.cs (2)
157if (span.Start == 0) 162return syntaxTree.GetRoot(cancellationToken).FindTrivia(span.Start - 1, findInsideTrivia);
TriviaDataFactory.ComplexTrivia.cs (1)
55var formatSpanEnd = commonToken2.Kind() == SyntaxKind.None ? commonToken1.Span.End : commonToken2.Span.Start;
TriviaRewriter.cs (1)
103return TextSpan.FromBounds(_node.FullSpan.Start, pair.Item2.SpanStart);
WrappingFormattingRule.cs (2)
191if (operation.TextSpan.Start >= span.Start && operation.TextSpan.End <= span.End && operation.Option.HasFlag(SuppressOption.NoWrappingIfOnSingleLine))
Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes (35)
AbstractAssignOutParametersCodeFixProvider.cs (1)
142foreach (var container in unassignedParameters.Keys.OrderByDescending(n => n.Span.Start))
AddInheritdocCodeFixProvider.cs (1)
126var indentation = sourceText.GetLeadingWhitespaceOfLineAtPosition(node.FullSpan.Start);
ArrowExpressionClausePlacementCodeFixProvider.cs (1)
58var arrowToken = root.FindToken(diagnostic.Location.SourceSpan.Start);
ConditionalExpressionPlacementCodeFixProvider.cs (1)
58var questionToken = root.FindToken(diagnostic.Location.SourceSpan.Start);
ConsecutiveBracePlacementCodeFixProvider.cs (1)
72var token = root.FindToken(diagnostic.Location.SourceSpan.Start);
ConvertNamespaceTransform.cs (1)
143if (tree.IsEntirelyWithinStringLiteral(textLine.Span.Start, cancellationToken))
CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProvider.cs (1)
42var token = root.FindToken(diagnosticSpan.Start);
CSharpAddYieldCodeFixProvider.cs (2)
110var symbol = model.GetEnclosingSymbol(node.Span.Start, cancellationToken); 217var ancestors = root.FindToken(span.Start).GetAncestors<SyntaxNode>();
CSharpAsAndMemberAccessCodeFixProvider.cs (1)
47foreach (var diagnostic in diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start))
CSharpCodeGenerationHelpers.cs (1)
203return contextTree?.GetRoot(cancellationToken).FindToken(contextLocation!.SourceSpan.Start).Parent;
CSharpCodeGenerationService.cs (5)
403return Cast<TDeclarationNode>(AppendTriviaAtPosition(newMember, positionOfRemovedNode - destination.FullSpan.Start, triviaOfRemovedNode)); 411return Cast<TDeclarationNode>(AppendTriviaAtPosition(newAccessor, positionOfRemovedNode - destination.FullSpan.Start, triviaOfRemovedNode)); 419return Cast<TDeclarationNode>(AppendTriviaAtPosition(newCompilationUnit, positionOfRemovedNode - destination.FullSpan.Start, triviaOfRemovedNode)); 427return Cast<TDeclarationNode>(AppendTriviaAtPosition(newParameter, positionOfRemovedNode - destination.FullSpan.Start, triviaOfRemovedNode)); 434return Cast<TDeclarationNode>(AppendTriviaAtPosition(newTypeParameter, positionOfRemovedNode - destination.FullSpan.Start, triviaOfRemovedNode));
CSharpDisambiguateSameVariableCodeFixProvider.cs (2)
102var enclosingType = semanticModel.GetEnclosingNamedType(span.Start, cancellationToken); 128var memberContainer = matchingMember.ContainingType.ToMinimalDisplayString(semanticModel, span.Start);
CSharpIndentationService.Indenter.cs (3)
58var line = indenter.Text.Lines.GetLineFromPosition(trivia.FullSpan.Start); 59if (line.GetFirstNonWhitespacePosition() != trivia.FullSpan.Start) 63return new IndentationResult(trivia.FullSpan.Start, 0);
CSharpMakeMethodAsynchronousCodeFixProvider.cs (1)
50var token = root.FindToken(diagnostic.Location.SourceSpan.Start);
CSharpRemoveUnusedLocalFunctionCodeFixProvider.cs (3)
54var localFunctions = diagnostics.OrderBy(static (d1, d2) => d2.Location.SourceSpan.Start - d1.Location.SourceSpan.Start) 55.Select(d => root.FindToken(d.Location.SourceSpan.Start))
CSharpReplaceDefaultLiteralCodeFixProvider.cs (2)
46var token = syntaxRoot.FindToken(context.Span.Start); 74var defaultToken = syntaxRoot.FindToken(span.Start);
CSharpUseIndexOperatorCodeFixProvider.cs (1)
48foreach (var diagnostic in diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start))
HideBaseCodeFixProvider.cs (1)
40var token = root.FindToken(diagnosticSpan.Start);
J\s\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\SyntaxTreeExtensions.cs\SyntaxTreeExtensions.cs (1)
124stack += (position - token.Span.Start);
RemoveInKeywordCodeFixProvider.cs (1)
45var token = root.FindToken(diagnosticSpan.Start);
RemoveNewModifierCodeFixProvider.cs (1)
43var token = root.FindToken(diagnosticSpan.Start);
UseUtf8StringLiteralCodeFixProvider.cs (3)
123.Where(a => a.Initializer?.ElementValues.FirstOrDefault()?.Syntax.SpanStart == diagnostic.Location.SourceSpan.Start) 171if (argument.Span.Start == location.SourceSpan.Start)
Microsoft.CodeAnalysis.CSharp.CodeStyle.UnitTests (1)
RemoveUnusedParametersTests.cs (1)
1227var sortedDiagnostics = diagnostics.OrderBy(d => d.Location.SourceSpan.Start).ToArray();
Microsoft.CodeAnalysis.CSharp.EditorFeatures (28)
BlockCommentEditing\BlockCommentEditingCommandHandler.cs (4)
124containsBlockCommentStartString = currentLine.LineNumber == textSnapshot.GetLineFromPosition(blockComment.FullSpan.Start).LineNumber; 144var commentStart = blockComment.FullSpan.Start; 243? blockComment.FullSpan.Start 291if (span.Start < caretPosition && caretPosition < span.End)
CompleteStatement\CompleteStatementCommandHandler.cs (4)
163if (!openingDelimiter.IsKind(SyntaxKind.None) && openingDelimiter.Span.Start >= caretPosition 290return (caret >= condition.Span.Start && caret <= condition.Span.End); 406return caretPosition > declaration.Span.Start && caretPosition <= declaration.Span.End; 411caretPosition > forStatementSyntax.Initializers.Span.Start &&
Interactive\CSharpSendToInteractiveSubmissionProvider.cs (1)
127: root.FindTokenOnRightOfPosition(selectionSpan.Start);
RawStringLiteral\RawStringLiteralCommandHandler_TypeChar.cs (1)
69edit.Insert(textChange.Span.Start, textChange.NewText);
StringCopyPaste\KnownSourcePasteProcessor.cs (7)
201edits.Add(new TextChange(new TextSpan(StringExpressionBeforePaste.Span.Start, 0), dollarSignsToAdd)); 205edits.Add(new TextChange(new TextSpan(StringExpressionBeforePasteInfo.ContentSpans.First().Start, 0), quotesToAdd)); 226edits.Add(new TextChange(new TextSpan(StringExpressionBeforePasteInfo.EndDelimiterSpan.Start, 0), NewLine + IndentationWhitespace)); 244if (beforeSelection && interpolation.Span.End > _selectionSpanBeforePaste.Start) 247if (!beforeSelection && interpolation.Span.Start < _selectionSpanBeforePaste.End) 251edits.Add(new TextChange(new TextSpan(interpolation.CloseBraceToken.Span.Start, 0), new string('}', dollarSignsToAdd))); 270TextBeforePaste.GetLineAndOffset(_selectionSpanBeforePaste.Start, out var line, out var offset);
StringCopyPaste\StringCopyPasteCommandHandler.cs (1)
263return textBeforePaste.ToString(TextSpan.FromBounds(lastLine.Span.Start, quotePosition));
StringCopyPaste\StringCopyPasteData.cs (2)
116if (selectionSpan.Start > firstOverlappingChar.Value.Span.Start)
StringCopyPaste\StringCopyPasteHelpers.cs (4)
203for (int currentIndex = span.Start, contentEnd = span.End; currentIndex < contentEnd;) 535if (commonIndentPrefix[commonPrefixLength] != text[lineWhitespaceSpan.Start + commonPrefixLength]) 554if (spans.First().Length > 0 && text[spans.First().Start] == '"') 563for (var i = span.Start; i < span.End; i++)
StringCopyPaste\StringInfo.cs (1)
210while (end > interpolatedString.StringEndToken.Span.Start && text[end - 1] == '"')
StringCopyPaste\UnknownSourcePasteProcessor.cs (3)
133edits.Add(new TextChange(new TextSpan(StringExpressionBeforePaste.Span.Start, 0), dollarSignsToAdd)); 137edits.Add(new TextChange(new TextSpan(StringExpressionBeforePasteInfo.ContentSpans.First().Start, 0), quotesToAdd)); 221edits.Add(new TextChange(new TextSpan(StringExpressionBeforePasteInfo.EndDelimiterSpan.Start, 0), NewLine + IndentationWhitespace));
Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (21)
CommentSelection\CSharpCommentSelectionTests.cs (1)
119SetupSelection(doc.GetTextView(), doc.SelectedSpans.Select(s => Span.FromBounds(s.Start, s.End)));
EditAndContinue\BreakpointSpansTests.cs (4)
82itemInspector: span => "[|" + source.Substring(span.Start, span.Length) + "|]"); 84var expectedEnvelope = expectedSpans.IsEmpty ? default : TextSpan.FromBounds(expectedSpans[0].Start, expectedSpans[^1].End); 97if (BreakpointSpans.TryGetClosestBreakpointSpan(root, p, out var span) && span.Start > lastSpan.Start)
EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (3)
56var expectedText = source.Substring(expected.Start, expected.Length); 57var token = tree.GetRoot().FindToken(expected.Start); 65var actualText = source.Substring(actual.Start, actual.Length);
ExtractMethod\MiscTests.cs (1)
133view.TextBuffer.CurrentSnapshot, testDocument.SelectedSpans[0].Start, testDocument.SelectedSpans[0].Length), isReversed: false);
FixInterpolatedVerbatimString\FixInterpolatedVerbatimStringCommandHandlerTests.cs (1)
71Assert.Equal(expectedSpans.Single().Start, view.Caret.Position.BufferPosition.Position);
LineSeparators\LineSeparatorTests.cs (1)
549foreach (var span in spans.OrderBy(t => t.Start))
PdbSourceDocument\AbstractPdbSourceDocumentTests.cs (2)
119Assert.Equal(expectedSpan.Start, actualSpan.Start);
RemoveUnusedParametersTests.cs (1)
1227var sortedDiagnostics = diagnostics.OrderBy(d => d.Location.SourceSpan.Start).ToArray();
SplitStringLiteral\SplitStringLiteralCommandHandlerTests.cs (3)
90Assert.Equal(originalSelections.Last().Start, view.Caret.Position.BufferPosition.Position); 107Assert.Equal(expectedSpans.Last().Start, view.Caret.Position.BufferPosition.Position); 117Assert.Equal(originalSelections.Last().Start, view.Caret.Position.BufferPosition.Position);
StringCopyPaste\StringCopyPasteCommandHandlerTests.cs (1)
169caretPosition = caretSpan.Start;
StringIndentation\StringIndentationTests.cs (1)
48var firstLine = text.Lines.GetLineFromPosition(region.IndentSpan.Start);
TypeInferrer\TypeInferrerTests.cs (2)
35var position = node?.SpanStart ?? textSpan.Start; 70var token = root.FindToken(textSpan.Start);
Microsoft.CodeAnalysis.CSharp.EditorFeatures2.UnitTests (1)
EmbeddedLanguages\Json\CSharpJsonParserTests.cs (1)
208element.Add(new XAttribute("Start", d.Span.Start));
Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (2)
PDB\CSharpPDBTestBase.cs (2)
40var startLine = text.Lines.GetLineFromPosition(span.Start); 42var startColumn = span.Start - startLine.Start + 1;
Microsoft.CodeAnalysis.CSharp.Emit2.UnitTests (2)
Semantics\PatternMatchingTests2.cs (2)
2028var gotModel = model.TryGetSpeculativeSemanticModel(returnStatement.Location.SourceSpan.Start, modifiedReturnStatement, out var speculativeModel); 2069var gotModel = model.TryGetSpeculativeSemanticModel(returnStatement.Location.SourceSpan.Start, modifiedReturnStatement, out var speculativeModel);
Microsoft.CodeAnalysis.CSharp.Features (125)
AbstractAssignOutParametersCodeFixProvider.cs (1)
142foreach (var container in unassignedParameters.Keys.OrderByDescending(n => n.Span.Start))
AddInheritdocCodeFixProvider.cs (1)
126var indentation = sourceText.GetLeadingWhitespaceOfLineAtPosition(node.FullSpan.Start);
ArrowExpressionClausePlacementCodeFixProvider.cs (1)
58var arrowToken = root.FindToken(diagnostic.Location.SourceSpan.Start);
BraceCompletion\AbstractCurlyBraceOrBracketCompletionService.cs (1)
198var newTextChangeText = formattedText.GetSubText(new TextSpan(newRange.Span.Start + amountToShift, newRange.NewLength)).ToString();
BraceMatching\BlockCommentBraceMatcher.cs (1)
38var startBrace = new TextSpan(trivia.FullSpan.Start, "/**".Length);
ChangeSignature\ChangeSignatureFormattingRule.cs (1)
44span = TextSpan.FromBounds(Math.Max(baseToken.Span.End, span.Start), span.End);
CodeFixes\GenerateMethod\GenerateDeconstructMethodCodeFixProvider.cs (1)
53var token = root.FindToken(span.Start);
CodeRefactorings\CSharpRefactoringHelpersService.cs (1)
44position > typeDecl.CloseBraceToken.Span.Start)
CodeRefactorings\EnableNullable\EnableNullableCodeRefactoringProvider.cs (2)
46var token = root.FindToken(textSpan.Start, findInsideTrivia: true); 48token = root.FindToken(textSpan.Start - 1, findInsideTrivia: true);
CodeRefactorings\SyncNamespace\CSharpSyncNamespaceCodeRefactoringProvider.cs (1)
37var position = span.Start;
CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (1)
61var node = root.FindToken(textSpan.Start).Parent;
Completion\CompletionProviders\DeclarationName\DeclarationNameRecommender.NameGenerator.cs (1)
84var text = baseName.Substring(@break.Start, @break.Length);
Completion\CompletionProviders\ImportCompletion\TypeImportCompletionProvider.cs (1)
68var position = item.Span.Start;
Completion\CompletionProviders\OperatorsAndIndexer\UnnamedSymbolCompletionProvider_Operators.cs (1)
146dotLikeToken.Kind() == SyntaxKind.DotDotToken ? dotLikeToken.Span.Start + 1 : dotLikeToken.Span.End),
ConditionalExpressionPlacementCodeFixProvider.cs (1)
58var questionToken = root.FindToken(diagnostic.Location.SourceSpan.Start);
ConsecutiveBracePlacementCodeFixProvider.cs (1)
72var token = root.FindToken(diagnostic.Location.SourceSpan.Start);
ConvertNamespace\ConvertNamespaceCodeRefactoringProvider.cs (1)
44var position = span.Start;
ConvertNamespaceTransform.cs (1)
143if (tree.IsEntirelyWithinStringLiteral(textLine.Span.Start, cancellationToken))
ConvertProgram\ConvertToProgramMainCodeRefactoringProvider.cs (1)
42var position = span.Start;
ConvertToRawString\ConvertRegularStringToRawStringCodeRefactoringProvider.cs (2)
63var token = root.FindToken(span.Start); 197var token = root.FindToken(span.Start);
CSharpAddBracesDiagnosticAnalyzer.cs (1)
131var ifStatementSpanWithoutElse = TextSpan.FromBounds(statement.Span.Start, embeddedStatement.Span.End);
CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProvider.cs (1)
42var token = root.FindToken(diagnosticSpan.Start);
CSharpAddYieldCodeFixProvider.cs (2)
110var symbol = model.GetEnclosingSymbol(node.Span.Start, cancellationToken); 217var ancestors = root.FindToken(span.Start).GetAncestors<SyntaxNode>();
CSharpAsAndMemberAccessCodeFixProvider.cs (1)
47foreach (var diagnostic in diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start))
CSharpDisambiguateSameVariableCodeFixProvider.cs (2)
102var enclosingType = semanticModel.GetEnclosingNamedType(span.Start, cancellationToken); 128var memberContainer = matchingMember.ContainingType.ToMinimalDisplayString(semanticModel, span.Start);
CSharpInlineDeclarationDiagnosticAnalyzer.cs (3)
329var localStatementStart = localStatement.Span.Start; 330var argumentNodeStart = argumentNode.Span.Start; 338var descendentStart = descendentNode.Span.Start;
CSharpMakeMethodAsynchronousCodeFixProvider.cs (1)
50var token = root.FindToken(diagnostic.Location.SourceSpan.Start);
CSharpRemoveUnnecessaryNullableDirectiveDiagnosticAnalyzer.cs (1)
236if (IntervalTree.HasIntervalThatOverlapsWith(span.Start, span.End))
CSharpRemoveUnreachableCodeDiagnosticAnalyzer.cs (2)
79firstUnreachableStatement.SpanStart != sourceSpan.Start) 125var span = TextSpan.FromBounds(section[0].FullSpan.Start, section.Last().FullSpan.End);
CSharpRemoveUnusedLocalFunctionCodeFixProvider.cs (3)
54var localFunctions = diagnostics.OrderBy(static (d1, d2) => d2.Location.SourceSpan.Start - d1.Location.SourceSpan.Start) 55.Select(d => root.FindToken(d.Location.SourceSpan.Start))
CSharpReplaceDefaultLiteralCodeFixProvider.cs (2)
46var token = syntaxRoot.FindToken(context.Span.Start); 74var defaultToken = syntaxRoot.FindToken(span.Start);
CSharpUseIndexOperatorCodeFixProvider.cs (1)
48foreach (var diagnostic in diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start))
CSharpUseLocalFunctionDiagnosticAnalyzer.cs (1)
212var descendentStart = descendentNode.Span.Start;
Debugging\BreakpointResolver.cs (1)
42var token = tree.GetRoot(cancellationToken).FindToken(location.SourceSpan.Start);
Debugging\CSharpBreakpointResolutionService.cs (1)
36if (tree == null || !BreakpointSpans.TryGetBreakpointSpan(tree, textSpan.Start, cancellationToken, out var span))
Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.cs (6)
145if (_ignoredSpans?.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) ?? false) 162if (_ignoredSpans?.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) ?? false) 179if (_ignoredSpans?.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) ?? false) 196if (_ignoredSpans?.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) ?? false) 234if (_ignoredSpans?.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) ?? false) 251if (_ignoredSpans?.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) ?? false)
EditAndContinue\BreakpointSpans.cs (8)
200position <= switchExpression.CloseBraceToken.Span.Start: 202switchArm = switchExpression.Arms.LastOrDefault(arm => position >= arm.FullSpan.Start) ?? switchExpression.Arms.First(); 240if (property.Initializer != null && position >= property.Initializer.FullSpan.Start) 336position > constructorSyntax.ExpressionBody.ArrowToken.Span.Start) 434if (position < doStatement.Statement.Span.Start) 491else if (position < forEachStatement.InKeyword.FullSpan.Start) 503else if (position < forEachStatement.Expression.FullSpan.Start) 816return TextSpan.FromBounds(firstSpan.Value.Start, constructorBody.Span.End);
EditAndContinue\CSharpEditAndContinueAnalyzer.cs (3)
328var position = span.Start; 442Debug.Assert(position == switchExpression.Span.Start); 1908=> (first.Length > 0 && second.Length > 0) ? TextSpan.FromBounds(first.Start, second.End) : (first.Length > 0) ? first : (second.Length > 0) ? second : defaultSpan;
ExtractMethod\CSharpMethodExtractor.Analyzer.cs (1)
95var info = model.GetSpeculativeTypeInfo(SelectionResult.FinalSpan.Start, SyntaxFactory.ParseName(symbol.Name), SpeculativeBindingOption.BindAsExpression);
ExtractMethod\CSharpMethodExtractor.cs (1)
39var originalSpanStart = OriginalSelectionResult.OriginalSpan.Start;
ExtractMethod\CSharpSelectionValidator.cs (6)
207var firstTokenInSelection = root.FindTokenOnRightOfPosition(adjustedSpan.Start, includeSkipped: false); 409? Math.Min(selectionInfo.FirstTokenInOriginalSpan.SpanStart, selectionInfo.OriginalSpan.Start) 410: selectionInfo.FirstTokenInFinalSpan.FullSpan.Start; 514if (textSpan.Start > previousLine.End) 516return TextSpan.FromBounds(textSpan.Start, previousLine.EndIncludingLineBreak); 519return TextSpan.FromBounds(textSpan.Start, previousLine.End);
GenerateDefaultConstructors\CSharpGenerateDefaultConstructorsService.cs (3)
39if (helpers.IsOnTypeHeader(semanticDocument.Root, textSpan.Start, out var typeDeclaration) || 40helpers.IsBetweenTypeMembers(semanticDocument.Text, semanticDocument.Root, textSpan.Start, out typeDeclaration)) 47var node = semanticDocument.Root.FindToken(textSpan.Start).GetAncestor<TypeSyntax>();
GenerateMember\GenerateVariable\CSharpGenerateVariableService.cs (2)
152var startIndex = identifierName.Span.Start - localRoot.Span.Start;
GoToDefinition\CSharpGoToDefinitionSymbolService.cs (3)
36? foundContinuedLoop.GetFirstToken().Span.Start 64return foundReturnableConstruct.GetFirstToken().Span.Start; 67return symbol.Locations.FirstOrNone().SourceSpan.Start;
HideBaseCodeFixProvider.cs (1)
40var token = root.FindToken(diagnosticSpan.Start);
Highlighting\KeywordHighlighters\AsyncAwaitHighlighter.cs (1)
116spans[^1] = TextSpan.FromBounds(lastSpan.Start, mod.Span.End);
ImplementInterface\AbstractChangeImplementationCodeRefactoringProvider.cs (2)
131var token = root.FindToken(span.Start); 145: TextSpan.FromBounds(explicitName.FullSpan.Start, identifier.FullSpan.End);
ImplementInterface\CSharpImplementInterfaceCodeFixProvider.cs (1)
47var token = root.FindToken(span.Start);
InlineHints\CSharpInlineParameterNameHintsService.cs (2)
64buffer.Add((argument.Span.Start, identifierArgument, parameter, GetKind(argument.Expression))); 82buffer.Add((argument.Span.Start, identifierArgument, parameter, GetKind(argument.Expression)));
InvokeDelegateWithConditionalAccessAnalyzer.cs (2)
200if (nextToken.Span.Start < ifStatement.Span.End) 202fadeLocation = Location.Create(tree, TextSpan.FromBounds(nextToken.Span.Start, ifStatement.Span.End));
RemoveInKeywordCodeFixProvider.cs (1)
45var token = root.FindToken(diagnosticSpan.Start);
RemoveNewModifierCodeFixProvider.cs (1)
43var token = root.FindToken(diagnosticSpan.Start);
SignatureHelp\AbstractCSharpSignatureHelpProvider.LightweightOverloadResolution.cs (1)
287if (position <= arguments.GetSeparator(i).Span.Start)
SignatureHelp\AttributeSignatureHelpProvider.cs (2)
119currentSpan.Start == SignatureHelpUtilities.GetSignatureHelpSpan(expression.ArgumentList!).Start)
SignatureHelp\ConstructorInitializerSignatureHelpProvider.cs (2)
133currentSpan.Start == SignatureHelpUtilities.GetSignatureHelpSpan(initializer.ArgumentList).Start)
SignatureHelp\ElementAccessExpressionSignatureHelpProvider.cs (2)
120return TextSpan.FromBounds(conditional.Span.Start, openBracket.FullSpan.End); 145currentSpan.Start != expression.SpanStart)
SignatureHelp\InitializerExpressionSignatureHelpProvider.cs (2)
87currentSpan.Start == SignatureHelpUtilities.GetSignatureHelpSpan(expression).Start)
SignatureHelp\InvocationExpressionSignatureHelpProvider.cs (2)
186currentSpan.Start == SignatureHelpUtilities.GetSignatureHelpSpan(expression.ArgumentList).Start)
SignatureHelp\ObjectCreationExpressionSignatureHelpProvider.cs (2)
154currentSpan.Start == SignatureHelpUtilities.GetSignatureHelpSpan(expression.ArgumentList).Start)
SignatureHelp\PrimaryConstructorBaseTypeSignatureHelpProvider.cs (2)
112currentSpan.Start == SignatureHelpUtilities.GetSignatureHelpSpan(expression.ArgumentList).Start)
SignatureHelp\TupleConstructionSignatureHelpProvider.cs (1)
50if (currentSpan.Start == parenthesizedExpression.SpanStart)
Snippets\AbstractCSharpTypeSnippetProvider.cs (1)
63var line = sourceText.Lines.GetLineFromPosition(triviaSpan.Start);
Snippets\CSharpConstructorSnippetProvider.cs (1)
57var line = sourceText.Lines.GetLineFromPosition(triviaSpan.Start);
Snippets\CSharpElseSnippetProvider.cs (1)
79var line = sourceText.Lines.GetLineFromPosition(triviaSpan.Start);
Snippets\CSharpForEachLoopSnippetProvider.cs (1)
116var line = sourceText.Lines.GetLineFromPosition(triviaSpan.Start);
Snippets\CSharpIfSnippetProvider.cs (1)
37var line = sourceText.Lines.GetLineFromPosition(triviaSpan.Start);
Snippets\CSharpSnippetFunctionService.cs (2)
37var token = syntaxTree.FindTokenOnRightOfPosition(switchExpressionSpan.Start, cancellationToken); 60var typeSpan = new TextSpan(caseGenerationLocation.Start + "case ".Length, fullyQualifiedTypeName.Length);
Snippets\CSharpWhileLoopSnippetProvider.cs (1)
37var line = sourceText.Lines.GetLineFromPosition(triviaSpan.Start);
SplitStringLiteral\InterpolatedStringSplitter.cs (1)
54else if (content.Span.Start >= CursorPosition)
SplitStringLiteral\StringSplitter.cs (1)
131return (newRoot2, rightExpression.Span.Start + indentString.Length + StringOpenQuoteLength());
Structure\CSharpStructureHelpers.cs (1)
268var startPosition = firstComment.HasValue ? firstComment.Value.FullSpan.Start : startToken.SpanStart;
Structure\Providers\BlockSyntaxStructureProvider.cs (1)
90var start = parent.Span.Start;
Structure\Providers\DisabledTextTriviaStructureProvider.cs (1)
30var startPos = trivia.FullSpan.Start;
Structure\Providers\DocumentationCommentStructureProvider.cs (1)
31var startPos = documentationComment.FullSpan.Start;
Structure\Providers\RegionDirectiveStructureProvider.cs (1)
19var prefixLength = kw.Span.End - simpleDirective.Span.Start;
TaskList\CSharpTaskListService.cs (1)
41var start = trivia.FullSpan.Start + index;
UseExpressionBody\UseExpressionBodyCodeRefactoringProvider.cs (1)
68var position = textSpan.Start;
UseUtf8StringLiteralCodeFixProvider.cs (3)
123.Where(a => a.Initializer?.ElementValues.FirstOrDefault()?.Syntax.SpanStart == diagnostic.Location.SourceSpan.Start) 171if (argument.Span.Start == location.SourceSpan.Start)
Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (11)
Semantics\ImplicitObjectCreationTests.cs (2)
4158int nodeLocation = node.Location.SourceSpan.Start; 4185int nodeLocation = node.Location.SourceSpan.Start;
Semantics\InitOnlyMemberTests.cs (2)
3154speculativeModel.GetSpeculativeSymbolInfo(p.FullSpan.Start, p, SpeculativeBindingOption.BindAsExpression); 3159speculativeModel.GetSpeculativeTypeInfo(p.FullSpan.Start, p, SpeculativeBindingOption.BindAsExpression);
Semantics\SuppressAccessibilityChecksTests.cs (7)
55var position = invocation.FullSpan.Start; 73var position = invocation.FullSpan.Start; 88var position = invocation.FullSpan.Start; 125var symbolInfo = model.GetSpeculativeSymbolInfo(expr.FullSpan.Start, 175var position = invocation.FullSpan.Start; 234speculativeModel.GetSpeculativeSymbolInfo(p.FullSpan.Start, p, SpeculativeBindingOption.BindAsExpression); 239speculativeModel.GetSpeculativeTypeInfo(p.FullSpan.Start, p, SpeculativeBindingOption.BindAsExpression);
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (6)
Compilation\UsedAssembliesTests.cs (1)
145var beforeUsings = source.Substring(0, unit.Usings.First().FullSpan.Start);
Symbols\AnonymousTypesSemanticsTests.cs (2)
2037intervals.Sort((x, y) => x.Start.CompareTo(y.Start));
Symbols\Source\LocationTests.cs (1)
47Assert.Equal(start, pos.SourceSpan.Start);
Symbols\Source\MethodTests.cs (2)
2068Assert.Equal(keywordPos, span.Start); 2089Assert.Equal(keywordPos, span.Start);
Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests (42)
Diagnostics\DiagnosticTest.cs (13)
2322Assert.Equal(PragmaWarningState.Default, syntaxTree.GetPragmaDirectiveWarningState(MessageProvider.Instance.GetIdForErrorCode(168), GetSpanIn(syntaxTree, "public class").Start)); 2323Assert.Equal(PragmaWarningState.Disabled, syntaxTree.GetPragmaDirectiveWarningState(MessageProvider.Instance.GetIdForErrorCode(168), GetSpanIn(syntaxTree, "public static").Start)); 2324Assert.Equal(PragmaWarningState.Disabled, syntaxTree.GetPragmaDirectiveWarningState(MessageProvider.Instance.GetIdForErrorCode(219), GetSpanIn(syntaxTree, "public static").Start)); 2325Assert.Equal(PragmaWarningState.Default, syntaxTree.GetPragmaDirectiveWarningState(MessageProvider.Instance.GetIdForErrorCode(168), GetSpanIn(syntaxTree, "int x").Start)); 2326Assert.Equal(PragmaWarningState.Disabled, syntaxTree.GetPragmaDirectiveWarningState(MessageProvider.Instance.GetIdForErrorCode(219), GetSpanIn(syntaxTree, "int x").Start)); 2327Assert.Equal(PragmaWarningState.Disabled, syntaxTree.GetPragmaDirectiveWarningState(MessageProvider.Instance.GetIdForErrorCode(168), GetSpanIn(syntaxTree, "int y").Start)); 2328Assert.Equal(PragmaWarningState.Disabled, syntaxTree.GetPragmaDirectiveWarningState(MessageProvider.Instance.GetIdForErrorCode(219), GetSpanIn(syntaxTree, "int y").Start)); 2329Assert.Equal(PragmaWarningState.Default, syntaxTree.GetPragmaDirectiveWarningState(MessageProvider.Instance.GetIdForErrorCode(168), GetSpanIn(syntaxTree, "int z").Start)); 2330Assert.Equal(PragmaWarningState.Default, syntaxTree.GetPragmaDirectiveWarningState(MessageProvider.Instance.GetIdForErrorCode(219), GetSpanIn(syntaxTree, "int z").Start)); 2351Assert.Equal(PragmaWarningState.Default, syntaxTree.GetPragmaDirectiveWarningState(MessageProvider.Instance.GetIdForErrorCode(168), GetSpanIn(syntaxTree, "static void").Start)); 2352Assert.Equal(PragmaWarningState.Disabled, syntaxTree.GetPragmaDirectiveWarningState(MessageProvider.Instance.GetIdForErrorCode(168), GetSpanIn(syntaxTree, "var x").Start)); 2353Assert.Equal(PragmaWarningState.Disabled, syntaxTree.GetPragmaDirectiveWarningState(MessageProvider.Instance.GetIdForErrorCode(219), GetSpanIn(syntaxTree, "var y").Start)); 2369Assert.Equal(PragmaWarningState.Disabled, syntaxTree.GetPragmaDirectiveWarningState(MessageProvider.Instance.GetIdForErrorCode(168), GetSpanIn(syntaxTree, "static void").Start));
Diagnostics\LocationsTests.cs (6)
90TextSpan xToCloseBraceSpan = new TextSpan(xSpan.Start, sampleProgram.IndexOf('}') - xSpan.Start + 1); 400Assert.InRange(diag.Location.SourceSpan.End, diag.Location.SourceSpan.Start, syntaxTree.GetText().Length); 465Assert.InRange(diag.Location.SourceSpan.Start, 0, syntaxTree.GetText().Length); 567Assert.Equal(5, diagnostics[0].Location.SourceSpan.Start); 595Assert.Equal(0, diagnostics[0].Location.SourceSpan.Start);
LexicalAndXml\LexicalTests.cs (12)
3565Assert.Equal(16, trivia.Span.Start); 3570Assert.Equal(18, trivia.Span.Start); 3610Assert.Equal(16, trivia2.Span.Start); 3615Assert.Equal(18, trivia3.Span.Start); 3620Assert.Equal(33, trivia4.Span.Start); 3643Assert.Equal(16, trivia2.Span.Start); 3648Assert.Equal(18, trivia3.Span.Start); 3694Assert.Equal(19, trivia.Span.Start); 3699Assert.Equal(21, trivia.Span.Start); 3729Assert.Equal(19, trivia2.Span.Start); 3734Assert.Equal(21, trivia3.Span.Start); 3739Assert.Equal(36, trivia4.Span.Start);
LexicalAndXml\RawStringLiteralLexingTests.cs (2)
223var expectedDiagnosticSpans = spans.Single().Value.OrderBy(d => d.Start); 224var actualDiagnosticsSpans = diagnostics.Select(d => d.Location.SourceSpan).OrderBy(d => d.Start);
Parsing\RoundTrippingTests.cs (1)
66Assert.Equal(prevSpan.End, span.Start);
Syntax\LambdaUtilitiesTests.cs (1)
47var enclosingMethod = (IMethodSymbol)model.GetEnclosingSymbol(span.Value.Start);
Syntax\SyntaxNodeTests.cs (7)
711var position = identifier.Span.Start + 1; 743invalidSpan = new TextSpan(classDecl2.FullSpan.Start - 1, root.FullSpan.End); 950Assert.Equal(26, last.FullSpan.Start); 972Assert.Equal(list1[i].FullSpan.Start, list2[i].FullSpan.Start); 3514Assert.InRange(0, root.FullSpan.Start, root.FullSpan.End); 3519Assert.NotInRange(0, method.FullSpan.Start, method.FullSpan.End);
Microsoft.CodeAnalysis.CSharp.Workspaces (54)
Classification\ClassificationHelpers.cs (1)
503var tokens = SyntaxFactory.ParseTokens(text2, initialTokenPosition: textSpan.Start);
Classification\Worker.cs (2)
107AddClassification(TextSpan.FromBounds(token.Span.Start, token.Span.End - "u8".Length), type); 138var classificationSpanStart = _textSpan.Start;
Classification\Worker_DocumentationComments.cs (3)
24if (childFullSpan.Start > _textSpan.End) 28else if (childFullSpan.End < _textSpan.Start) 116spanStart = trivia.Span.Start + index;
CSharpCodeGenerationHelpers.cs (1)
203return contextTree?.GetRoot(cancellationToken).FindToken(contextLocation!.SourceSpan.Start).Parent;
CSharpCodeGenerationService.cs (5)
403return Cast<TDeclarationNode>(AppendTriviaAtPosition(newMember, positionOfRemovedNode - destination.FullSpan.Start, triviaOfRemovedNode)); 411return Cast<TDeclarationNode>(AppendTriviaAtPosition(newAccessor, positionOfRemovedNode - destination.FullSpan.Start, triviaOfRemovedNode)); 419return Cast<TDeclarationNode>(AppendTriviaAtPosition(newCompilationUnit, positionOfRemovedNode - destination.FullSpan.Start, triviaOfRemovedNode)); 427return Cast<TDeclarationNode>(AppendTriviaAtPosition(newParameter, positionOfRemovedNode - destination.FullSpan.Start, triviaOfRemovedNode)); 434return Cast<TDeclarationNode>(AppendTriviaAtPosition(newTypeParameter, positionOfRemovedNode - destination.FullSpan.Start, triviaOfRemovedNode));
CSharpIndentationService.Indenter.cs (3)
58var line = indenter.Text.Lines.GetLineFromPosition(trivia.FullSpan.Start); 59if (line.GetFirstNonWhitespacePosition() != trivia.FullSpan.Start) 63return new IndentationResult(trivia.FullSpan.Start, 0);
CSharpSyntaxFacts.cs (1)
1123return !branch.IsActive || !branch.BranchTaken ? TextSpan.FromBounds(branch.FullSpan.Start, position) : default;
CSharpVirtualCharService.cs (3)
206var lineStart = lineSpan.Start; 213? lineSpan.Start + indentationLength 315runeResults.Add(VirtualChar.Create(rune, TextSpan.FromBounds(span.Start, nextSpan.End)));
Formatting\CSharpSyntaxFormattingService.cs (2)
141return tokenEdits.Where(t => t.Span.Start >= token.FullSpan.Start).ToImmutableArray();
IndentBlockFormattingRule.cs (2)
129span = lastSection ? span : TextSpan.FromBounds(span.Start, endToken.FullSpan.End); 346AddIndentBlockOperation(list, firstToken, lastToken, TextSpan.FromBounds(firstToken.FullSpan.Start, lastToken.FullSpan.End));
J\s\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs\SyntaxNodeExtensions.cs (2)
641if (!textSpan.Contains(matchSpan.Start)) 797if (position < span.Start)
J\s\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxTreeExtensions.cs\SyntaxTreeExtensions.cs (13)
56positionBeforeModifiers = token.FullSpan.Start; 63positionBeforeModifiers = token.FullSpan.Start; 70positionBeforeModifiers = token.FullSpan.Start; 245if (position > fullSpan.Start && position < fullSpan.End) 252if (position > fullSpan.Start && position <= fullSpan.End) 271if (position > span.Start && position < span.End) 290? position > span.Start && position < span.End 291: position > span.Start && position <= span.End; 326if (position > span.Start && position <= span.End) 352if (position > span.Start && position <= span.End) 388for (int i = token.Span.End - 1, n = token.Span.Start; i >= n; i--) 440return (position > span.Start && position < span.End) 479return (position > span.Start && position < span.End)
J\s\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\SyntaxTreeExtensions.cs\SyntaxTreeExtensions.cs (1)
124stack += (position - token.Span.Start);
LanguageServices\FixAllSpanMappingService\CSharpFixAllSpanMappingService.cs (2)
49fixAllSpan = new TextSpan(root.FullSpan.Start, firstTypeOrNamespaceDecl.FullSpan.Start - 1);
OrganizeImports\CSharpOrganizeImportsService.Rewriter.cs (1)
88=> TextSpan.FromBounds(list.First().FullSpan.Start, list.Last().FullSpan.End);
Rename\CSharpRenameRewriterLanguageService.cs (6)
111newSpan = new TextSpan(oldSpan.Start, newSpan.Length); 320_renameSpansTracker.AddComplexifiedSpan(_documentId, oldSpan, new TextSpan(oldSpan.Start, newSpan.Length), _modifiedSubSpans); 352var symbols = RenameUtilities.GetSymbolsTouchingPosition(token.Span.Start, _semanticModel, _solution.Services, _cancellationToken); 877var token = await tree.GetTouchingTokenAsync(location.SourceSpan.Start, cancellationToken, findInsideTrivia: true).ConfigureAwait(false); 905var token = await location.SourceTree!.GetTouchingTokenAsync(location.SourceSpan.Start, cancellationToken, findInsideTrivia: true).ConfigureAwait(false); 1010implicitReferenceLocation.Location.SourceSpan.Start, cancellationToken, findInsideTrivia: false).ConfigureAwait(false);
SyntaxTriviaExtensions.cs (2)
157if (span.Start == 0) 162return syntaxTree.GetRoot(cancellationToken).FindTrivia(span.Start - 1, findInsideTrivia);
TriviaDataFactory.ComplexTrivia.cs (1)
55var formatSpanEnd = commonToken2.Kind() == SyntaxKind.None ? commonToken1.Span.End : commonToken2.Span.Start;
TriviaRewriter.cs (1)
103return TextSpan.FromBounds(_node.FullSpan.Start, pair.Item2.SpanStart);
WrappingFormattingRule.cs (2)
191if (operation.TextSpan.Start >= span.Start && operation.TextSpan.End <= span.End && operation.Option.HasFlag(SuppressOption.NoWrappingIfOnSingleLine))
Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests (2)
EmbeddedLanguages\VirtualChars\CSharpVirtualCharServiceTests.cs (2)
59for (var i = ch.Span.Start; i < ch.Span.End; i++) 91=> $"[{ConvertRuneToString(vc)},[{vc.Span.Start - _statementPrefix.Length},{vc.Span.End - _statementPrefix.Length}]]";
Microsoft.CodeAnalysis.EditorFeatures (54)
BraceMatching\BraceHighlightingViewTaggerProvider.cs (1)
157position > leftOfPosition.Value.RightSpan.Start)
BracePairs\BracePairsTaggerProvider.cs (1)
104new SnapshotSpan(snapshot, Span.FromBounds(bracePair.Start.Start, bracePair.End.End)),
Classification\Semantic\ClassificationUtilities.cs (2)
126var changedSpan = new TextSpan(range.Value.Span.Start, range.Value.NewLength); 127var member = service.GetContainingMemberDeclaration(root, changedSpan.Start);
Classification\Syntactic\SyntacticClassificationTaggerProvider.TagComputer.cs (1)
320? currentSnapshot.GetSpan(changeRange.Value.Span.Start, changeRange.Value.NewLength)
CommentSelection\AbstractCommentSelectionBase.cs (1)
179return snapshot.CreateTrackingSpan(Span.FromBounds(textSpan.Start, textSpan.End), spanTrackingMode);
CommentSelection\AbstractToggleBlockCommentBase.cs (22)
156var trackingSpan = TextSpan.FromBounds(intersectingBlockComments.First().Start, intersectingBlockComments.Last().End); 237if (blockCommentSelection.IsLocationCommented(selectedSpan.Start) && !startsWithCommentMarker) 239InsertText(textChanges, selectedSpan.Start, commentInfo.BlockCommentEndString); 240InsertText(textChanges, selectedSpan.Start, commentInfo.BlockCommentStartString); 259InsertText(textChanges, span.Start, commentInfo.BlockCommentStartString); 266DeleteText(textChanges, new TextSpan(spanToRemove.Start, commentInfo.BlockCommentStartString.Length)); 306for (var i = span.Start; i < span.End; i++) 366var selectedLine = snapshot.GetLineFromPosition(SelectedSpan.Start); 367var lineStartToCaretIsWhitespace = IsSpanWhitespace(TextSpan.FromBounds(selectedLine.Start, SelectedSpan.Start)); 368var caretToLineEndIsWhitespace = IsSpanWhitespace(TextSpan.FromBounds(SelectedSpan.Start, selectedLine.End)); 372&& SelectedSpan.Start < blockComment.Start 373&& snapshot.AreOnSameLine(SelectedSpan.Start, blockComment.Start)) 375if (IsSpanWhitespace(TextSpan.FromBounds(SelectedSpan.Start, blockComment.Start))) 382&& SelectedSpan.Start > blockComment.End 383&& snapshot.AreOnSameLine(SelectedSpan.Start, blockComment.End)) 385if (IsSpanWhitespace(TextSpan.FromBounds(blockComment.End, SelectedSpan.Start))) 412var spanStart = SelectedSpan.Start; 415if (commentedSpan.Start > spanStart) 418var possibleUncommentedSpan = TextSpan.FromBounds(spanStart, commentedSpan.Start);
Extensibility\NavigationBar\AbstractEditorNavigationBarItemService.cs (2)
82return Task.FromResult((document.Id, navigationSpan.Start, 0)); 90return Task.FromResult((documentId, span.Start, 0));
ExternalAccess\VSTypeScript\VSTypeScriptNavigationBarItemService.cs (1)
68_threadingContext, workspace, document.Id, navigationSpan.Start, virtualSpace: 0, NavigationOptions.Default, cancellationToken).ConfigureAwait(false);
InlineRename\AbstractEditorInlineRenameService.SymbolRenameInfo.cs (2)
108return new TextSpan(location.TextSpan.Start + index, searchName.Length); 128return new TextSpan(location.TextSpan.Start + position, replacementText.Length);
InlineRename\InlineRenameService.cs (1)
87var renameInfo = await editorRenameService.GetRenameInfoAsync(document, textSpan.Start, cancellationToken).ConfigureAwait(false);
InlineRename\InlineRenameSession.OpenTextBufferManager.cs (1)
345edit.Replace(change.Span.Start, change.Span.Length, change.NewText);
Intents\DeleteParameterIntentProvider.cs (1)
43priorDocument, priorSelection.Start, restrictToDeclarations: false, _globalOptionService.CreateProvider(), cancellationToken).ConfigureAwait(false);
Intents\RenameIntentProvider.cs (1)
42var renameInfo = await renameService.GetRenameInfoAsync(priorDocument, priorSelection.Start, cancellationToken).ConfigureAwait(false);
Interactive\InteractiveWorkspace.cs (1)
67edit.Replace(change.Span.Start, change.Span.Length, change.NewText);
Interactive\SendToInteractiveSubmissionProvider.cs (1)
74Select(span => new SnapshotSpan(snapshot, span.Start, span.Length));
NavigationBar\NavigationBarController_ModelComputation.cs (5)
191if (exactItem == null || span.Start >= exactItemStart) 194exactItemStart = span.Start; 197else if (span.Start > point && span.Start <= nextItemStart) 200nextItemStart = span.Start;
ReferenceHighlighting\ReferenceHighlightingViewTaggerProvider.cs (1)
196textSnapshot.GetSpan(Span.FromBounds(span.TextSpan.Start, span.TextSpan.End)), tag));
RenameTracking\RenameTrackingTaggerProvider.StateMachine.cs (1)
310if (text.AreOnSameLine(userSpan.Start, snapshotSpan.Start))
Structure\AbstractStructureTaggerProvider.cs (1)
270var startLine = snapshot.GetLineNumberFromPosition(region.TextSpan.Start);
Structure\StructureTag.cs (5)
28if (blockSpan.HintSpan.Start < blockSpan.TextSpan.Start) 34HeaderSpan = Span.FromBounds(blockSpan.HintSpan.Start, blockSpan.TextSpan.Start); 38var hintLine = snapshot.GetLineFromPosition(blockSpan.HintSpan.Start);
TextStructureNavigation\AbstractTextStructureNavigatorProvider.TextStructureNavigator.cs (2)
94if (trivia.Span.Start == position && _provider.ShouldSelectEntireTriviaFromStart(trivia)) 104if (token.Span.Length == 0 && token.Span.Start == textLength)
Microsoft.CodeAnalysis.EditorFeatures.Cocoa (6)
CommandHandlers\GoToMatchingBraceCommandHandler.cs (2)
53if (span.Value.Start < caretPosition) 54args.TextView.TryMoveCaretToAndEnsureVisible(args.SubjectBuffer.CurrentSnapshot.GetPoint(span.Value.Start));
Controller.Session_ComputeModel.cs (3)
102currentModel.GetCurrentSpanInSubjectBuffer(disconnectedBufferGraph.SubjectBufferSnapshot).Span.Start == items.ApplicableSpan.Start && 235return currentTextSpan.Value.Start > bestItems.ApplicableSpan.Start;
Snippets\CSharpSnippets\SnippetFunctions\SnippetFunctionGenerateSwitchCases.cs (1)
62var token = syntaxTree.FindTokenOnRightOfPosition(expressionSpan.Start, cancellationToken);
Microsoft.CodeAnalysis.EditorFeatures.DiagnosticsTests.Utilities (5)
CodeActions\AbstractCodeActionOrUserDiagnosticTest.cs (2)
482.OrderBy(location => location.SourceSpan.Start) 533segments.Add((documentOffset + diagnostic.Location.SourceSpan.Start, "{|" + markupKey + ":"));
MoveToNamespace\AbstractMoveToNamespaceTests.cs (1)
110testState.TestInvocationDocument.SelectedSpans.Single().Start,
MoveType\AbstractMoveTypeTest.cs (1)
58var codeActionTitle = string.Format(RenameTypeCodeActionTitle, expectedText.Substring(span.Start, span.Length));
SplitComments\AbstractSplitCommentCommandHandlerTests.cs (1)
69snapshotSpans.Add(new SnapshotSpan(originalSnapshot, new Span(selection.Start, selection.Length)));
Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities (51)
AbstractCommandHandlerTestState.cs (7)
84var cursorPosition = cursorDocument.CursorPosition ?? cursorDocument.SelectedSpans.First(ss => ss.IsEmpty).Start; 93Assert.True(cursorPosition == firstSpan.Start || cursorPosition == firstSpan.End 94|| cursorPosition == lastSpan.Start || cursorPosition == lastSpan.End, 104if (cursorPosition == firstSpan.Start || cursorPosition == lastSpan.End) 107boxSelectionStart = new SnapshotPoint(_subjectBuffer.CurrentSnapshot, firstSpan.Start); 109isReversed = cursorPosition == firstSpan.Start; 115boxSelectionEnd = new SnapshotPoint(_subjectBuffer.CurrentSnapshot, lastSpan.Start);
BraceHighlighting\MultiCharacterBraceHighlightingTests.cs (2)
39Debug.Assert(text.Substring(braces.Value.LeftSpan.Start, braces.Value.LeftSpan.Length) == "<@"); 40Debug.Assert(text.Substring(braces.Value.RightSpan.Start, braces.Value.RightSpan.Length) == "@>");
BracePairs\AbstractBracePairsTests.cs (2)
55var sortedSpans = expectedSpans.Sort((s1, s2) => s1.Start - s2.Start);
Classification\AbstractClassifierTests.cs (3)
69var actualOrdered = actual.OrderBy((t1, t2) => t1.TextSpan.Start - t2.TextSpan.Start); 71var actualFormatted = actualOrdered.Select(a => new FormattedClassification(allCode.Substring(a.TextSpan.Start, a.TextSpan.Length), a.ClassificationType));
Classification\ClassificationTestHelper.cs (3)
37actualClassificationList.Sort((t1, t2) => t1.TextSpan.Start - t2.TextSpan.Start); 54var text = actualText.Substring(actual.TextSpan.Start, actual.TextSpan.Length);
CommentSelection\AbstractToggleCommentTestBase.cs (2)
41SetupSelection(doc.GetTextView(), doc.SelectedSpans.Select(s => Span.FromBounds(s.Start, s.End))); 60SetupSelection(document.GetTextView(), document.SelectedSpans.Select(s => Span.FromBounds(s.Start, s.End)));
CompleteStatement\AbstractCompleteStatementTests.cs (2)
95var isReversed = selectedSpan.Start == startCaretPosition; 97view.Selection.Select(new SnapshotSpan(view.TextSnapshot, selectedSpan.Start, selectedSpan.Length), isReversed);
Completion\AbstractArgumentProviderTests`1.cs (1)
108? arguments.IndexOf(arguments.Single(argument => argument.FullSpan.Start <= position && argument.FullSpan.End >= position))
DocumentationComments\AbstractDocumentationCommentTests.cs (2)
156var isReversed = selectedSpan.Start == startCaretPosition; 158view.Selection.Select(new SnapshotSpan(view.TextSnapshot, selectedSpan.Start, selectedSpan.Length), isReversed);
EditAndContinue\EditAndContinueTestHelpers.cs (2)
358var result = root.FindToken(span.Start).Parent!; 463.OrderBy(partners => partners.Key.GetLocation().SourceSpan.Start)
EditAndContinue\Extensions.cs (1)
23firstLine: includeFirstLines ? newSource.Lines.GetLineFromPosition(d.Span.Start).ToString().Trim() : null));
GoToAdjacentMember\AbstractGoToAdjacentMemberTests.cs (1)
53Assert.Equal(hostDocument.SelectedSpans.Single().Start, targetPosition.Value);
KeywordHighlighting\AbstractKeywordHighlighterTests.cs (1)
61var position = cursorSpan.Start + i;
ReassignedVariable\AbstractReassignedVariableTests.cs (2)
34var expectedSpans = workspace.Documents.Single().SelectedSpans.OrderBy(s => s.Start); 35var actualSpans = result.OrderBy(s => s.Start);
SpellCheck\AbstractSpellCheckSpanTests.cs (4)
35actual = actual.Sort((s1, s2) => s1.TextSpan.Start - s2.TextSpan.Start); 36expected = expected.Sort((s1, s2) => s1.TextSpan.Start - s2.TextSpan.Start);
Structure\AbstractSyntaxStructureProviderTests.cs (4)
107Assert.Equal(expected.TextSpan.Start, actual.TextSpan.Start); 109Assert.Equal(expected.HintSpan.Start, actual.HintSpan.Start);
TaskList\AbstractTaskListTests.cs (2)
54var line = initialTextSnapshot.GetLineFromPosition(span.Start); 58Assert.Equal(todo.MappedSpan.StartLinePosition.Character, span.Start - line.Start);
TypeInferrer\TypeInferrerTestBase.cs (1)
61if (await CanUseSpeculativeSemanticModelAsync(document, textSpan.Start))
Workspaces\TestHostDocument.cs (2)
244_textView.Selection.Select(new SnapshotSpan(_textView.TextSnapshot, new Span(span.Start, span.Length)), false); 333edit.Replace(change.Span.Start, change.Span.Length, change.NewText);
Workspaces\TestWorkspace.cs (7)
492mappedSpans[string.Empty] = mappedSpans[string.Empty].OrderBy(s => s.End).ThenBy(s => -s.Start).ToImmutableArray(); 543var sortedAndNamedSpans = namedSpans.OrderBy(kvp => kvp.Value.Single().Start) 555var spanLocation = spanNameToListMap.Value.Single().Start; 588var span = new Span(matchingSpan.Start, matchingSpan.Length); 604var caretOffsetInSpan = documentWithSpan.CursorPosition.Value - matchingSpan.Start; 641var markupSpanStart = markupSpan.Start; 642var markupSpanEndExclusive = markupSpan.Start + markupSpan.Length;
Microsoft.CodeAnalysis.EditorFeatures.Text (3)
Extensions.SnapshotSourceText.cs (1)
181var editorSpan = new Span(textSpan.Start, textSpan.Length);
Shared\Extensions\TextSpanExtensions.cs (2)
16=> new Span(textSpan.Start, textSpan.Length); 22=> new TextSpan(textSpan.Start + offset, textSpan.Length);
Microsoft.CodeAnalysis.EditorFeatures.UnitTests (27)
CodeGeneration\CodeGenerationTests.cs (2)
921var token = semanticModel.SyntaxTree.GetRoot().FindToken(selection.Start); 933var token = SemanticModel.SyntaxTree.GetRoot().FindToken(destSpan.Start);
Completion\CompletionServiceTests.cs (2)
135var token = root.FindToken(result.Start); 144text, startSpan.Start, IsWordCharacter, IsWordCharacter, alwaysExtendEndSpan: true);
Diagnostics\DiagnosticAnalyzerServiceTests.cs (2)
952var pragma1 = root.FindTrivia(diagnostics[0].DataLocation.UnmappedFileSpan.GetClampedTextSpan(text).Start).ToString(); 954var pragma2 = root.FindTrivia(diagnostics[1].DataLocation.UnmappedFileSpan.GetClampedTextSpan(text).Start).ToString();
EditAndContinue\ActiveStatementsMapTests.cs (2)
61Assert.Equal(new Range(5, 6), ActiveStatementsMap.GetSpansStartingInSpan(span.Start, span.End, array, startPositionComparer: (x, y) => x.Start.CompareTo(y)));
EditorAdapter\SpanExtensionsTest.cs (1)
25Assert.Equal(start, textSpan.Start);
InheritanceMargin\InheritanceMarginTests.cs (2)
158var actualDocumentSpans = actualTarget.DefinitionItem.SourceSpans.OrderBy(documentSpan => documentSpan.SourceSpan.Start).ToImmutableArray(); 159var expectedDocumentSpans = expectedTarget.DocumentSpans.OrderBy(documentSpan => documentSpan.SourceSpan.Start).ToImmutableArray();
MetadataAsSource\AbstractMetadataAsSourceTests.cs (1)
61var line = text.Lines.GetLineFromPosition(metadataAsSourceFile.IdentifierLocation.SourceSpan.Start);
MetadataAsSource\AbstractMetadataAsSourceTests.TestContext.cs (2)
152Assert.Equal(expectedSpan.Start, actualSpan.Start);
RenameTracking\RenameTrackingTaggerProviderTests.cs (5)
359state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "cation"); 372state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "Complex"); 385state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "Dog"); 404state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "_"); 810state.EditorOperations.ReplaceText(new Span(textSpan.Start, textSpan.Length), "Go");
Snippets\RoslynLSPSnippetConvertTests.cs (5)
495var textChange = new TextChange(new TextSpan(stringSpan.Start, 0), text.Substring(stringSpan.Start, stringSpan.Length)); 500var lspSnippetString = await RoslynLSPSnippetConverter.GenerateLSPSnippetAsync(document, cursorPosition!.Value, placeholders, textChange, stringSpan.Start, CancellationToken.None).ConfigureAwait(false); 512var identifier = text.Substring(spans[0].Start, spans[0].Length); 513var placeholders = spans.Select(span => span.Start).ToImmutableArray();
Utilities\PatternMatcherTests.cs (2)
421result.Add(identifier.Substring(span.Start, span.Length)); 477var actualSpans = flattened.OrderBy(s => s.Start).ToList();
ValueTracking\AbstractBaseValueTrackingTests.cs (1)
85item.SourceText.GetLineAndOffset(item.Span.Start, out var lineStart, out var _);
Microsoft.CodeAnalysis.EditorFeatures.Wpf (8)
InlineRename\UI\Adornment\RenameFlyout.xaml.cs (1)
52IdentifierTextBox.Select(_viewModel.StartingSelection.Start, _viewModel.StartingSelection.Length);
Interactive\InteractiveDocumentNavigationService.cs (1)
62var snapshotSpan = new SnapshotSpan(textSnapshot, textSpan.Start, textSpan.Length);
NavigateTo\NavigateToItemDisplay.cs (1)
85new[] { new DescriptionRun((sourceText.Lines.IndexOf(span.Start) + 1).ToString()) }))
Peek\PeekableItemSource.cs (1)
137workspace, document.Id, item.SourceSpan.Start, cancellationToken).ConfigureAwait(false))
Peek\PeekHelpers.cs (1)
51var node = root.FindToken(identifierLocation.SourceSpan.Start).Parent;
SignatureHelp\Controller.Session_ComputeModel.cs (3)
102currentModel.GetCurrentSpanInSubjectBuffer(disconnectedBufferGraph.SubjectBufferSnapshot).Span.Start == items.ApplicableSpan.Start && 235return currentTextSpan.Value.Start > bestItems.ApplicableSpan.Start;
Microsoft.CodeAnalysis.EditorFeatures2.UnitTests (23)
Diagnostics\DiagnosticServiceTests.vb (4)
1219OrderBy(Function(d) d.DataLocation.UnmappedFileSpan.GetClampedTextSpan(text).Start).ToArray() 1335OrderBy(Function(d) d.DataLocation.UnmappedFileSpan.GetClampedTextSpan(text).Start). 1383OrderBy(Function(d) d.DataLocation.UnmappedFileSpan.GetClampedTextSpan(text).Start). 1387Dim spanAtCaret = New TextSpan(diagnostic.DataLocation.UnmappedFileSpan.GetClampedTextSpan(text).Start, 0)
Expansion\AbstractExpansionTest.vb (2)
35Dim node = GetExpressionSyntaxWithSameSpan(root.FindToken(span.Start).Parent, span.End) 40Dim node = GetExpressionSyntaxWithSameSpan(root.FindToken(span.Start).Parent, span.End)
FindReferences\FindReferencesTests.vb (3)
192g.Select(Function(i) i.SourceSpan).OrderBy(Function(s) s.Start). 443builder.Append(text.GetSubText(New TextSpan(position, span.Start - position))) 500Return loc.IsInSource AndAlso Not loc.SourceTree.IsHiddenPosition(loc.SourceSpan.Start)
GoToDefinition\GoToDefinitionTestsBase.vb (1)
88Assert.Equal(expected.Start, mockDocumentNavigationService._position)
InlineHints\AbstractInlineHintsTests.vb (1)
53For Each nameAndSpan In nameAndSpansList.OrderBy(Function(x) x.span.Start)
Peek\PeekTests.vb (1)
456Dim expectedPosition = New SnapshotPoint(snapshot, document.AnnotatedSpans(name).Single().Start)
ReferenceHighlighting\AbstractReferenceHighlightingTests.vb (1)
64For Each nameAndSpan In nameAndSpansList.OrderBy(Function(x) x.Span.Start)
Rename\RenameEngineResult.vb (4)
223Dim newToken = newTree.GetRoot.FindToken(newLocation.Start, findInsideTrivia:=True) 228newText = newToken.ToFullString().Substring(newLocation.Start - newToken.FullSpan.Start, newLocation.Length) 270Select $"{spanText} @{document.Name}[{location.ConflictCheckSpan.Start}..{location.ConflictCheckSpan.End})"))
Simplification\AbstractSimplificationTests.vb (5)
81Dim node = root.FindToken(span.Start).Parent 87Dim token = root.FindToken(span.Start) 93Dim node = root.FindToken(span.Start).Parent.Parent 99Dim node = root.FindToken(span.Start).Parent.Parent.Parent 105Dim node = GetExpressionSyntaxWithSameSpan(root.FindToken(span.Start).Parent, span.End)
Simplification\TypeNameSimplifierTest.vb (1)
4253Dim node = root.FindToken(span.Start).Parent.Parent
Microsoft.CodeAnalysis.ExternalAccess.FSharp (2)
Internal\Editor\FSharpNavigationBarItemService.cs (2)
74if (navigationService.CanNavigateToPosition(workspace, document.Id, span.Start, virtualSpace: 0, cancellationToken)) 76navigationService.TryNavigateToPosition(workspace, document.Id, span.Start, virtualSpace: 0, cancellationToken);
Microsoft.CodeAnalysis.Features (239)
AbstractConflictMarkerCodeFixProvider.cs (4)
75var position = context.Span.Start; 389(d1, d2) => d1.Location.SourceSpan.Start - d2.Location.SourceSpan.Start).ToImmutableArray(); 402var position = diagnostic.Location.SourceSpan.Start;
AbstractConvertToAsyncCodeFixProvider.cs (1)
51var ancestors = root.FindToken(span.Start).GetAncestors<SyntaxNode>();
AbstractFileHeaderHelper.cs (2)
71fileHeaderStart = Math.Min(trivia.FullSpan.Start, fileHeaderStart); 94fileHeaderStart = trivia.FullSpan.Start;
AbstractIteratorCodeFixProvider.cs (1)
47var ancestors = root.FindToken(span.Start).GetAncestors<SyntaxNode>();
AbstractMultipleBlankLinesCodeFixProvider.cs (1)
57var token = root.FindToken(diagnostic.AdditionalLocations[0].SourceSpan.Start);
AbstractRemoveAsyncModifierCodeFixProvider.cs (1)
75foreach (var diagnostic in diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start))
AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (3)
102textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 110textSpan = TextSpan.FromBounds(previous.Value.textSpan.Start, nodeEnd); 116textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd);
AbstractRemoveUnnecessaryParenthesesDiagnosticAnalyzer.cs (2)
133var expressionFirstLine = lines.GetLineFromPosition(parenthesizedExpressionLocation.SourceSpan.Start); 136return Location.Create(parenthesizedExpression.SyntaxTree, TextSpan.FromBounds(parenthesizedExpressionLocation.SourceSpan.Start, textSpanEndPosition));
AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (1)
562if (pragma.Span.End <= diagnostic.Location.SourceSpan.Start)
AbstractRemoveUnusedValuesCodeFixProvider.cs (3)
257return diagnostics.GroupBy(d => syntaxFacts.GetContainingMemberDeclaration(root, d.Location.SourceSpan.Start) ?? root); 351diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start), 361diagnostics.OrderBy(d => d.Location.SourceSpan.Start),
AbstractSimplifyInterpolationHelpers.cs (2)
49.OrderBy(t => t.Start) 188: TextSpan.FromBounds(sequence.First().Span.Start, sequence.Last().Span.End);
AbstractUseIsNullForReferenceEqualsCodeFixProvider.cs (1)
59foreach (var diagnostic in diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start))
AddFileBanner\AbstractAddFileBannerCodeRefactoringProvider.cs (1)
56var position = span.Start;
AddImport\AbstractAddImportFeatureService.cs (1)
87var node = root.FindToken(span.Start, findInsideTrivia: true)
BraceCompletion\AbstractBraceCompletionService.cs (1)
98return new BraceCompletionContext(document, leftToken.GetLocation().SourceSpan.Start, rightToken.GetLocation().SourceSpan.End, caretLocation);
BraceMatching\IBraceMatchingServiceExtensions.cs (4)
36if (braces1.HasValue && position >= braces1.Value.LeftSpan.Start && position < braces1.Value.LeftSpan.End) 41else if (braces2.HasValue && position > braces2.Value.RightSpan.Start && position <= braces2.Value.RightSpan.End) 46else if (braces2.HasValue && position > braces2.Value.LeftSpan.Start && position <= braces2.Value.LeftSpan.End) 51else if (braces1.HasValue && position >= braces1.Value.RightSpan.Start && position < braces1.Value.RightSpan.End)
ChangeSignature\AbstractChangeSignatureService.cs (4)
93var context = await GetChangeSignatureContextAsync(document, span.Start, restrictToDeclarations: true, fallbackOptions, cancellationToken).ConfigureAwait(false); 650if (position < parameters.Span.Start) 664if (position <= parameters.GetSeparator(i).Span.Start) 936.OrderByDescending(s => s.Locations.First().SourceSpan.Start);
ClassifiedSpansAndHighlightSpanFactory.cs (6)
61var sourceLine = sourceText.Lines.GetLineFromPosition(referenceSpan.Start); 68return TextSpan.FromBounds(Math.Min(firstNonWhitespacePosition, referenceSpan.Start), sourceLine.End); 75start: narrowSpan.Start - widenedSpan.Start, 97new ClassifiedSpan(ClassificationTypeNames.Text, TextSpan.FromBounds(widenedSpan.Start, narrowSpan.Start)),
CodeFixes\GenerateMember\AbstractGenerateMemberCodeFixProvider.cs (1)
65var token = root.FindToken(span.Start);
CodeFixes\Suppression\AbstractSuppressionBatchFixAllProvider.cs (1)
313tuple => tuple.action, tuple => tuple.diagnostic?.Location.SourceSpan.Start ?? 0);
CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (2)
268if (syntaxTree.GetLineVisibility(span.Start, cancellationToken) == LineVisibility.Hidden) 276var indexOfLine = lines.IndexOf(span.Start);
CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.PragmaBatchFixHelpers.cs (4)
133static bool IsPriorSpan(TextSpan span, TextChange textChange) => span.End <= textChange.Span.Start; 134static bool IsFollowingSpan(TextSpan span, TextChange textChange) => span.Start >= textChange.Span.End; 161var newStart = currentSpan.Start + delta; 169currentSpan = new TextSpan(currentSpan.Start, newLength);
CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.PragmaHelpers.cs (6)
46diagnosticSpan = new TextSpan(diagnosticSpan.Start + spanChange, diagnosticSpan.Length); 73? trivia.FullSpan.End <= currentDiagnosticSpan.Start 74: trivia.FullSpan.Start >= currentDiagnosticSpan.End; 120else if (startToken.FullSpan.Start == 0) 224var subtreeRoot = root.FindNode(new TextSpan(previousOfStart.FullSpan.Start, spanEnd - previousOfStart.FullSpan.Start));
CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction_Pragma.cs (3)
125bool shouldIncludeTrivia(SyntaxTrivia t) => isStartToken ? t.FullSpan.End <= diagnosticSpan.Start : t.FullSpan.Start >= diagnosticSpan.End; 209start: Math.Max(0, trivia.Span.Start - 1),
CodeLens\CodeLensReferencesService.cs (6)
119var position = location.SourceSpan.Start; 131var spanStart = token.Span.Start - textLine.Span.Start; 155token.Span.Start, 163referenceSpan.Start, 220var enclosingSymbol = semanticModel.GetEnclosingSymbol(location.SourceSpan.Start, cancellationToken);
CodeRefactoringHelpers.cs (7)
77if (node.FullSpan.Contains(selection.Start)) 79var selectionStartToken = node.FindToken(selection.Start); 86var beginningNode = node.FindToken(node.Span.Start).Parent; 98return beginningNode.Span.End <= selection.Start || endNode.Span.Start >= selection.End; 106/// Returns empty Span with original <see cref="TextSpan.Start"/> in case it contains only whitespace. 116var start = span.Start;
CodeRefactorings\AbstractRefactoringHelpersService.cs (9)
92var location = selectionTrimmed.Start; 193else if (previousToken != default && previousToken.Span.End == commaToken.Span.Start) 207if (tokenToRight == default || tokenToRight.FullSpan.Start == location) 228if (tokenOnLocation.Span.Start >= location) 245var tokenLine = sourceText.Lines.GetLineFromPosition(tokenOnLocation.Span.Start); 312var location = tokenToRightOrIn.Span.Start; 335if (rightNode.Span.Start != location) 338if (rightNodeSpanWithoutAttributes.Start != location) 535var argumentStartLine = sourceText.Lines.GetLineFromPosition(correctTypeNode.Span.Start).LineNumber;
CodeRefactorings\AddMissingImports\AbstractAddMissingImportsFeatureService.cs (3)
134.Select(changes => new TextSpan(changes.Key.Start, changes.Sum(change => change.NewText!.Length))); 253_text.GetLineAndOffset(previousToken.Span.Start, out var previousLine, out _); 254_text.GetLineAndOffset(currentToken.Span.Start, out var currentLine, out _);
CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (2)
875return x.Span.Start - y.Span.Start;
Completion\Providers\AbstractAwaitCompletionProvider.cs (1)
195var position = item.Span.Start;
Completion\Providers\AbstractDocCommentCompletionProvider.cs (4)
276var replacementSpan = TextSpan.FromBounds(text[itemSpan.Start - 1] == '<' && beforeCaretText[0] == '<' ? itemSpan.Start - 1 : itemSpan.Start, itemSpan.End); 279var newPosition = replacementSpan.Start + beforeCaretText.Length;
Completion\Providers\AbstractInternalsVisibleToCompletionProvider.cs (2)
253var token = root.FindToken(result.Start); 262text, startSpan.Start, IsWordCharacter, IsWordCharacter, alwaysExtendEndSpan: true);
Completion\Providers\AbstractObjectInitializerCompletionProvider.cs (1)
88contextPosition: initializerLocation.SourceSpan.Start,
Completion\Providers\AbstractPartialMethodCompletionProvider.cs (2)
107var displayText = GetDisplayText(method, semanticModel, span.Start); 116span.Start,
Completion\Providers\ImportCompletionProvider\AbstractImportCompletionProvider.cs (2)
126var addImportContextNode = root.FindToken(completionItem.Span.Start, findInsideTrivia: true).Parent; 203return await IsInImportsDirectiveAsync(document, completionItem.Span.Start, cancellationToken).ConfigureAwait(false);
Completion\Providers\Snippets\AbstractSnippetCompletionProvider.cs (5)
50var lspSnippet = await RoslynLSPSnippetConverter.GenerateLSPSnippetAsync(allChangesDocument, snippet.CursorPosition, snippet.Placeholders, change, item.Span.Start, cancellationToken).ConfigureAwait(false); 54if (change.Span.Start > item.Span.Start) 56var textSpan = TextSpan.FromBounds(item.Span.Start, change.Span.End); 133return (newDocument, span.Start);
Completion\Providers\SymbolCompletionItem.cs (1)
191position = item.Span.Start;
Completion\Utilities.cs (2)
31var totalOldSpan = TextSpan.FromBounds(changes.First().Span.Start, changes.Last().Span.End); 40var totalNewSpan = new TextSpan(totalOldSpan.Start, totalOldSpan.Length + sumOfDeltas);
ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (1)
88var position = span.Start;
ConvertForToForEach\AbstractConvertForToForEachCodeRefactoringProvider.cs (1)
108var containingType = semanticModel.GetEnclosingNamedType(textSpan.Start, cancellationToken);
ConvertToInterpolatedString\ConvertRegularStringToInterpolatedStringRefactoringProvider.cs (1)
39var token = root.FindToken(context.Span.Start);
ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (2)
248var token = root.FindToken(renamedToken.span.Start); 263var position = span.Start;
Debugging\AbstractBreakpointResolver.cs (1)
84var textSpan = new TextSpan(location.SourceSpan.Start, 0);
Debugging\DebugDataTipInfo.cs (1)
21=> Span.Length == 0 && Span.Start == 0 && Text == null;
DocumentationComments\AbstractDocumentationCommentSnippetService.cs (4)
75var replaceSpan = new TextSpan(token.Span.Start, spanToReplaceLength); 101var line = text.Lines.GetLineFromPosition(documentationComment.FullSpan.Start); 242var start = token.Span.Start; 281var replaceSpan = new TextSpan(token.Span.Start, 0);
DocumentHighlighting\AbstractDocumentHighlightsService.cs (1)
319var token = root.FindToken(location.SourceSpan.Start, findInsideTrivia: true);
DocumentSpanExtensions.cs (1)
35return tree.IsHiddenPosition(documentSpan.SourceSpan.Start, cancellationToken);
EditAndContinue\AbstractEditAndContinueAnalyzer.cs (15)
708var line = text.Lines.GetLineFromPosition(diagnostic.Span.Start); 710lineText = text.ToString(TextSpan.FromBounds(diagnostic.Span.Start, Math.Min(diagnostic.Span.Start + 120, line.End))); 817var node = TryGetNode(topMatch.OldRoot, oldStatementSpan.Start); 833Log.Write("Invalid active statement span: [{0}..{1})", oldStatementSpan.Start, oldStatementSpan.End); 847var adjustedOldStatementStart = oldMember.FullSpan.Contains(oldStatementSpan.Start) ? oldStatementSpan.Start : oldMember.SpanStart; 883Log.Write("Invalid active statement span: [{0}..{1})", oldStatementSpan.Start, oldStatementSpan.End); 1325if (!bodyMatch.NewRoot.Span.Contains(newStatementSyntaxSpan.Start)) 1330newStatementSyntax = bodyMatch.NewRoot.FindToken(newStatementSyntaxSpan.Start).Parent; 1572var token = syntaxRoot.FindToken(unmappedActiveStatementSpan.Start); 1710envelope.Start, 1713startPositionComparer: (x, y) => x.UnmappedSpan.Start.CompareTo(y)); 1717if (!hole.Contains(statements[i].UnmappedSpan.Start)) 2157lastNewToken.HasTrailingTrivia ? lastNewToken.Span.End : newTokensEnum.Current.FullSpan.Start,
EditAndContinue\ActiveStatementsMap.cs (2)
195oldRoot.FullSpan.Contains(unmappedSpan.Start) && 244Debug.Assert(builder.IsSorted(Comparer<UnmappedActiveStatement>.Create((x, y) => x.UnmappedSpan.Start.CompareTo(y.UnmappedSpan.End))));
EmbeddedLanguages\DateAndTime\DateAndTimeEmbeddedCompletionProvider.cs (1)
113properties.Add(StartKey, textChange.Span.Start.ToString());
EmbeddedLanguages\DateAndTime\EmbeddedCompletionContext.cs (1)
66else if (ch.Span.Start >= endPosition)
EmbeddedLanguages\Json\JsonLexer.cs (1)
318=> TextSpan.FromBounds(Text[startInclusive].Span.Start, Text[endExclusive - 1].Span.End);
EmbeddedLanguages\Json\JsonParser.cs (3)
155return d1.Value.Span.Start <= d2.Value.Span.Start ? d1 : d2; 593: new TextSpan(token.VirtualChars[0].Span.Start, 0);
EmbeddedLanguages\Json\JsonParser.StrictSyntaxChecker.cs (1)
242return new EmbeddedDiagnostic(FeaturesResources.Invalid_escape_sequence, TextSpan.FromBounds(chars[i].Span.Start, chars[i + 1].Span.End));
EmbeddedLanguages\Json\LanguageServices\JsonBraceMatcher.cs (1)
79if (!fullSpan.Value.Contains(ch.Span.Start))
EmbeddedLanguages\RegularExpressions\LanguageServices\EmbeddedCompletionContext.cs (1)
47? parentOpt.GetSpan().Start
EmbeddedLanguages\RegularExpressions\LanguageServices\RegexEmbeddedCompletionProvider.cs (1)
104properties.Add(StartKey, textChange.Span.Start.ToString());
EmbeddedLanguages\RegularExpressions\RegexLexer.cs (1)
179=> TextSpan.FromBounds(Text[startInclusive].Span.Start, Text[endExclusive - 1].Span.End);
EmbeddedLanguages\RegularExpressions\RegexParser.cs (1)
714: new TextSpan(token.VirtualChars[0].Span.Start, 0);
ExtractClass\AbstractExtractClassRefactoringProvider.cs (1)
94memberNodeSymbolPairs.First().node.FullSpan.Start,
ExtractInterface\AbstractExtractInterfaceService.cs (1)
53var typeAnalysisResult = await AnalyzeTypeAtPositionAsync(document, span.Start, TypeDiscoveryRule.TypeNameOnly, fallbackOptions, cancellationToken).ConfigureAwait(false);
ExtractMethod\AbstractSyntaxTriviaService.cs (3)
96var triviaAtBeginning = SplitTrivia(tokens[TriviaLocation.BeforeBeginningOfSpan], tokens[TriviaLocation.AfterBeginningOfSpan], t => t.FullSpan.End <= textSpan.Start); 97var triviaAtEnd = SplitTrivia(tokens[TriviaLocation.BeforeEndOfSpan], tokens[TriviaLocation.AfterEndOfSpan], t => t.FullSpan.Start < textSpan.End); 113tokens[TriviaLocation.AfterBeginningOfSpan] = root.FindTokenOnRightOfPosition(textSpan.Start, includeSkipped: false);
ExtractMethod\MethodExtractor.VariableSymbol.cs (11)
165return leftLocation.SourceSpan.Start - rightLocation.SourceSpan.Start; 217Contract.ThrowIfFalse(_localSymbol.Locations[0].SourceSpan.Start != other._localSymbol.Locations[0].SourceSpan.Start); 219return _localSymbol.Locations[0].SourceSpan.Start - other._localSymbol.Locations[0].SourceSpan.Start; 241var token = tree.GetRoot(cancellationToken).FindToken(span.Start); 329Contract.ThrowIfFalse(locationLeft.SourceSpan.Start != locationRight.SourceSpan.Start); 331return locationLeft.SourceSpan.Start - locationRight.SourceSpan.Start;
ExtractMethod\SelectionValidator.cs (5)
107var token1 = root.FindToken(textSpan.Start); 123if (stmt.Span.End < textSpan.Start) 135if (stmt.SpanStart <= textSpan.Start) 167var token1 = root.FindToken(textSpan.Start); 179if (firstStatement == null && stmt.SpanStart >= textSpan.Start)
Formatting\FormattingRuleUtilities.cs (1)
18var position = (span.Start + span.End) / 2;
FormattingAnalyzerHelper.cs (4)
41if (oldText.GetSubText(new TextSpan(change.Span.Start + offset, change.NewText.Length)).ContentEquals(SourceText.From(change.NewText))) 43change = new TextChange(new TextSpan(change.Span.Start, offset), ""); 50if (oldText.GetSubText(new TextSpan(change.Span.Start, change.NewText.Length)).ContentEquals(SourceText.From(change.NewText))) 52change = new TextChange(new TextSpan(change.Span.Start + change.NewText.Length, offset), "");
FullyQualify\AbstractFullyQualifyService.cs (1)
69var node = root.FindToken(span.Start).GetAncestors<SyntaxNode>().First(n => n.Span.Contains(span));
GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (3)
53if (!helpers.IsOnTypeHeader(root, textSpan.Start, fullHeader: true, out var typeDeclaration) && 54!helpers.IsBetweenTypeMembers(sourceText, root, textSpan.Start, out typeDeclaration)) 109var displayString = typeArg.ToMinimalDisplayString(semanticModel, textSpan.Start);
GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.cs (2)
190if (!helpers.IsOnTypeHeader(root, textSpan.Start, out var typeDeclaration) && 191!helpers.IsBetweenTypeMembers(sourceText, root, textSpan.Start, out typeDeclaration))
GenerateDefaultConstructors\AbstractGenerateDefaultConstructorCodeFixProvider.cs (2)
31if (!headerFacts.IsOnTypeHeader(root, diagnostic.Location.SourceSpan.Start, fullHeader: true, out var typeDecl)) 40document, new TextSpan(typeName.Value.Span.Start, 0), context.Options, forRefactoring: false, cancellationToken).ConfigureAwait(false);
GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.State.cs (1)
69if (headerFacts.IsOnTypeHeader(semanticDocument.Root, textSpan.Start, fullHeader: true, out _))
GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (3)
84if (!helpers.IsOnTypeHeader(root, textSpan.Start, out var typeDeclaration) && 85!helpers.IsBetweenTypeMembers(sourceText, root, textSpan.Start, out typeDeclaration)) 188var typeDeclaration = syntaxFacts.GetContainingTypeDeclaration(root, textSpan.Start);
GenerateOverrides\GenerateOverridesCodeRefactoringProvider.cs (2)
44if (!helpers.IsOnTypeHeader(root, textSpan.Start, out var typeDeclaration) && 45!helpers.IsBetweenTypeMembers(sourceText, root, textSpan.Start, out typeDeclaration))
ImplementAbstractClass\AbstractImplementAbstractClassCodeFixProvider.cs (1)
33var token = root.FindToken(context.Span.Start);
InlineHints\AbstractInlineTypeHintsService.cs (2)
80AddParts(anonymousTypeService, finalParts, parts, semanticModel, span.Start); 91InlineHintHelpers.GetDescriptionFunction(span.Start, type.GetSymbolKey(cancellationToken: cancellationToken), displayOptions)));
InlineTemporary\AbstractInlineTemporaryCodeRefactoringProvider.cs (1)
45.Select(loc => root.FindToken(loc.Location.SourceSpan.Start).Parent as TIdentifierNameSyntax)
IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (1)
270.OrderByDescending(reference => reference.Location.SourceSpan.Start);
MoveStaticMembers\AbstractMoveStaticMembersRefactoringProvider.cs (1)
61memberNodeSymbolPairs.First().node.FullSpan.Start,
MoveToNamespace\AbstractMoveToNamespaceService.cs (2)
61var typeAnalysisResult = await AnalyzeTypeAtPositionAsync(document, span.Start, cancellationToken).ConfigureAwait(false); 254var moveSpan = new TextSpan(container.FullSpan.Start, 0);
NavigateTo\NavigateToUtilities.cs (1)
31var spanStart = item.SourceSpan.Start;
PullMemberUp\AbstractPullMemberUpRefactoringProvider.cs (1)
70memberNodeSymbolPairs.First().node.FullSpan.Start,
QuickInfo\IndentationHelper.cs (8)
45var startLineNumber = text.Lines.GetLineFromPosition(span.Start).LineNumber; 55if (deletion.Start > span.Start) 57var spanBeforeDeletion = TextSpan.FromBounds(span.Start, Math.Min(span.End, deletion.Start)); 64if (deletion.End > span.Start) 92var startLineNumber = text.Lines.GetLineFromPosition(span.TextSpan.Start).LineNumber; 110if (startLineFirstNonWhitespace.HasValue && startLineFirstNonWhitespace.Value < span.TextSpan.Start)
QuickInfo\QuickInfoUtilities.cs (1)
39var groups = await descriptionService.ToDescriptionGroupsAsync(semanticModel, span.Start, symbols, options, cancellationToken).ConfigureAwait(false);
RemoveUnnecessaryPragmaSuppressionsCodeFixProvider.cs (2)
44root.FindTrivia(diagnostic.Location.SourceSpan.Start).HasStructure) 89node = editor.OriginalRoot.FindTrivia(location.SourceSpan.Start).GetStructure()!;
ReplaceDocCommentTextWithTag\AbstractReplaceDocCommentTextWithTagCodeRefactoringProvider.cs (4)
29var token = root.FindToken(span.Start, findInsideTrivia: true); 56var symbol = GetEnclosingSymbol(semanticModel, span.Start, cancellationToken); 168var startInclusive = span.Start; 169var endExclusive = span.Start;
ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (2)
254var nameToken = root.FindToken(location.SourceSpan.Start); 294var nameToken = root.FindToken(location.SourceSpan.Start);
ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (1)
263var nameToken = root.FindToken(location.SourceSpan.Start, findInsideTrivia: true);
Shared\Naming\IdentifierNameParts.cs (1)
80words.Add(name.Substring(part.Start, part.Length));
Shared\Utilities\AnnotatedSymbolMapping.cs (1)
88var token = root.FindToken(location.SourceSpan.Start);
SimplifyConditionalCodeFixProvider.cs (1)
58diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start).ToImmutableArray(),
SimplifyTypeNames\AbstractSimplifyTypeNamesCodeFixProvider.cs (1)
48var token = root.FindToken(span.Start, findInsideTrivia: true);
SimplifyTypeNamesDiagnosticAnalyzerBase.cs (1)
258if (intervalTree.HasIntervalThatOverlapsWith(span.Start, span.End))
Snippets\RoslynLSPSnippetConverter.cs (3)
37var textChangeStart = textChange.Span.Start; 131var startPosition = textChange.Span.Start; 132var endPosition = textChange.Span.Start + textChangeText.Length;
Snippets\SnippetFunctionService.cs (1)
41var updatedTextSpan = new TextSpan(fieldSpan.Start, fullyQualifiedTypeName.Length);
SolutionCrawler\AbstractDocumentDifferenceService.cs (4)
112var oldMember = syntaxFactsService.GetContainingMemberDeclaration(oldRoot, range.Span.Start); 113var newMember = syntaxFactsService.GetContainingMemberDeclaration(newRoot, range.Span.Start); 153var oldMember = syntaxFactsService.GetContainingMemberDeclaration(oldRoot, range.Span.Start); 154var newMember = syntaxFactsService.GetContainingMemberDeclaration(newRoot, range.Span.Start);
SpellCheck\AbstractSpellCheckCodeFixProvider.cs (1)
57var token = syntaxRoot.FindToken(span.Start);
SplitOrMergeIfStatements\AbstractMergeIfStatementsCodeRefactoringProvider.cs (1)
60new TextSpan(upperIfOrElseIfSpan.Start, lowerIfOrElseIfSpan.End));
SplitOrMergeIfStatements\AbstractSplitIfStatementCodeRefactoringProvider.cs (2)
37var token = root.FindToken(textSpan.Start); 67var token = root.FindToken(tokenSpan.Start);
TaskList\AbstractTaskListService.cs (4)
133var startLine = text.Lines.GetLineFromPosition(fullSpan.Start); 140AppendTaskListItemsOnSingleLine(commentDescriptors, document, message, fullSpan.Start, items); 145var startMessage = text.ToString(TextSpan.FromBounds(fullSpan.Start, startLine.End)); 146AppendTaskListItemsOnSingleLine(commentDescriptors, document, startMessage, fullSpan.Start, items);
Wrapping\AbstractCodeActionComputer.cs (1)
180var span = TextSpan.FromBounds(edit.Left.Span.End, edit.Right.Span.Start);
Wrapping\AbstractWrappingCodeRefactoringProvider.cs (1)
44var position = span.Start;
Wrapping\BinaryExpression\BinaryExpressionCodeActionComputer.cs (1)
62OriginalSourceText.GetOffset(binaryExpression.Span.Start)
Wrapping\Edit.cs (2)
26if (left.Span.End > right.Span.Start) 83: base($"Left token had an end '{left.Span.End}' past the start of right token '{right.Span.Start}'")
Microsoft.CodeAnalysis.InteractiveHost (2)
Interactive\Core\InteractiveHost.Service.cs (2)
790displayedDiagnostics.Sort((d1, d2) => d1.Location.SourceSpan.Start - d2.Location.SourceSpan.Start);
Microsoft.CodeAnalysis.LanguageServer.Protocol (34)
Extensions\ProtocolConversions.cs (1)
373Math.Min(text.Length, span.Start),
Features\Diagnostics\DocumentAnalysisExecutor.cs (3)
292var startNode = service.GetContainingMemberDeclaration(root, span.Value.Start); 310return TextSpan.FromBounds(Math.Min(startSpan.Start, endSpan.Start), Math.Max(startSpan.End, endSpan.End));
Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer.IncrementalMemberEditAnalyzer.cs (9)
319Contract.ThrowIfFalse(member.FullSpan.Start == oldSpan.Start); 332if (diagnosticSpan.Start < oldSpan.Start) 335if (diagnostic.AdditionalLocations.Any(l => l.DocumentId != null && l.UnmappedFileSpan.GetClampedTextSpan(text).Start >= oldSpan.Start)) 351if (oldSpan.End <= diagnosticSpan.Start) 354if (diagnostic.AdditionalLocations.Any(l => l.DocumentId != null && oldSpan.End > l.UnmappedFileSpan.GetClampedTextSpan(text).Start)) 384var start = Math.Min(Math.Max(diagnosticSpan.Start + delta, 0), tree.Length);
Features\UnifiedSuggestions\UnifiedSuggestedActionSetComparer.cs (2)
46var startsDistance = Math.Abs(a.Start - b.Start);
Features\UnifiedSuggestions\UnifiedSuggestedActionsSource.cs (1)
360var currentStart = set.ApplicableToSpan.Value.Start;
Handler\Breakpoints\ValidateBreakableRangeHandler.cs (2)
81var breakpointSpan = result.IsLineBreakpoint ? new TextSpan(span.Start, length: 0) : result.TextSpan; 105breakpointSpan = secondResult.IsLineBreakpoint ? new TextSpan(span.Start, length: 0) : secondResult.TextSpan;
Handler\Completion\CompletionResolveHandler.cs (1)
159var relativeCaretPosition = caretPosition.Value - completionChangeSpan.Start;
Handler\InlineCompletions\InlineCompletionsHandler.cs (12)
143var snippetEndPosition = textChange.Span.Start + textChange.NewText!.Length; 148var spanToFormat = TextSpan.FromBounds(textChange.Span.Start, snippetEndPosition); 160snippetEndPosition = GetAdjustedSpan(formattingChanges, new TextSpan(snippetEndPosition, 0)).Start; 161var spanContainingFormattedSnippet = TextSpan.FromBounds(snippetShortcut.Start, snippetEndPosition); 172var fieldInSnippetContext = GetTextSpanInContextOfSnippet(fieldInFormattedText.Start, spanContainingFormattedSnippet.Start, fieldInFormattedText.Length); 181var caretInSnippetContext = GetTextSpanInContextOfSnippet(caretInFormattedText.Start, spanContainingFormattedSnippet.Start, caretInFormattedText.Length); 192var textChangesBefore = textChanges.Where(t => t.Span.End <= originalSpan.Start); 194return new TextSpan(originalSpan.Start + amountToAdjust, originalSpan.Length); 228var locationInDefaultSnippet = snippetSpan.Start; 231var locationInFinalSnippet = snippetSpan.Start;
Handler\InlineCompletions\XmlSnippetParser.ParsedXmlSnippet.cs (1)
63var className = await snippetFunctionService.GetContainingClassNameAsync(documentWithSnippet, fieldSpan.Start, cancellationToken).ConfigureAwait(false);
Handler\OnAutoInsert\OnAutoInsertHandler.cs (2)
222Debug.Assert(desiredCaretLocation >= textChange.Span.Start); 223var offsetInTextChange = desiredCaretLocation - textChange.Span.Start;
Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (2)
SpellCheck\SpellCheckTests.cs (2)
529var allSpans = annotatedSpans.SelectMany(kvp => kvp.Value.Select(textSpan => (kind: kvp.Key, textSpan)).OrderBy(t => t.textSpan.Start)); 533Start = ProtocolConversions.LinePositionToPosition(sourceText.Lines.GetLinePosition(t.textSpan.Start)),
Microsoft.CodeAnalysis.Remote.ServiceHub (1)
Services\SemanticClassification\RemoteSemanticClassificationService.Caching.cs (1)
188writer.WriteInt32(classifiedSpan.TextSpan.Start);
Microsoft.CodeAnalysis.Scripting (2)
Hosting\CommandLine\CommandLineRunner.cs (2)
376return (delta != 0) ? delta : d1.Location.SourceSpan.Start - d2.Location.SourceSpan.Start;
Microsoft.CodeAnalysis.Test.Utilities (5)
Diagnostics\DiagnosticDescription.cs (3)
284if (!_syntaxPredicate(d._location.SourceTree.GetRoot().FindToken(_location.SourceSpan.Start, true).Parent)) 297if (!d._syntaxPredicate(_location.SourceTree.GetRoot().FindToken(_location.SourceSpan.Start, true).Parent)) 544assertText.AppendLine(l.SourceTree.GetText().Lines.GetLineFromPosition(l.SourceSpan.Start).ToString());
MarkedSource\MarkupTestFile.cs (2)
215builder.Sort((left, right) => left.Start - right.Start);
Microsoft.CodeAnalysis.UnitTests (20)
CommonSyntaxTests.cs (2)
120Assert.Equal(8, correctSpan.Start); 157Assert.Equal(8, correctSpan.Start);
Diagnostics\SuppressMessageTargetSymbolResolverTests.cs (1)
1358expectedSymbols.Add(GetSymbolAtPosition(model, span.Start));
Text\LargeTextTests.cs (2)
162Assert.Equal(start, textLine.Span.Start); 164Assert.Equal(start, textLine.SpanIncludingLineBreak.Start);
Text\SourceTextTests.cs (1)
346Assert.Equal(Text.Substring(span.Start, span.Length), writer.ToString());
Text\StringText_LineTest.cs (2)
89Assert.Equal(start, line.Span.Start); 90Assert.Equal(start, line.SpanIncludingLineBreak.Start);
Text\StringTextTest.cs (2)
115Assert.Equal(start, textLine.Span.Start); 117Assert.Equal(start, textLine.SpanIncludingLineBreak.Start);
Text\StringTextTests_Default.cs (1)
61Assert.Equal(3 + newLine.Length, data.Lines[1].Span.Start);
Text\TextChangeTests.cs (2)
78Assert.Equal(6, changes[0].Span.Start); 1251Assert.True(position <= change.Span.Start);
Text\TextSpanTest.cs (7)
22Assert.Equal(0, span.Start); 31Assert.Equal(1, span.Start); 43Assert.Equal(0, span.Start); 90Assert.Equal(0, span.Start); 101Assert.Equal(0, span.Start); 113Assert.Equal(15, span.Start); 123Assert.Equal(0, span.Start);
Microsoft.CodeAnalysis.VisualBasic (67)
Analysis\FlowAnalysis\AbstractFlowPass.Regions.vb (1)
56Return Me._region.Contains(span.Start)
Analysis\FlowAnalysis\DataFlowPass.vb (1)
1188If isImplicitlyDeclared OrElse firstLocation Is Nothing OrElse firstLocation.SourceSpan.Start < node.SpanStart Then
Binding\Binder_Query.vb (1)
2273operatorNameSpan = TextSpan.FromBounds(operatorNameSpan.Start, right.Span.End)
CommandLine\CommandLineDiagnosticFormatter.vb (1)
61Dim sourceSpanStart = sourceSpan.Start
Compilation\VisualBasicCompilation.vb (3)
1710If Not Me.IsImportDirectiveUsed(infoTree, clauseSpans(0).Start) Then 1721If Not Me.IsImportDirectiveUsed(infoTree, clauseSpan.Start) Then 1756_lazyImportClauseDependencies.TryGetValue((infoTree, clauseSpan.Start), dependencies) Then
Compilation\VisualBasicDiagnosticFilter.vb (1)
183location.SourceTree.GetWarningState(id, location.SourceSpan.Start) = ReportDiagnostic.Suppress Then
GlobalImport.vb (2)
118Dim startindex = unmappedSpan.Start - _clause.Span.Start
Lowering\Instrumentation\CodeCoverageInstrumenter.vb (3)
550Return New Text.TextSpan(startSpan.Start, originalSpan.Length - (startSpan.Start - originalSpan.Start))
Scanner\Blender.vb (10)
94Dim start = NearestStatementThatContainsPosition(root, span.Start, fullSpan) 95Debug.Assert(start.Start <= span.Start) 101Return TextSpan.FromBounds(start.Start, [end].End) 156Dim start = Math.Min(span.Start, Math.Max(0, fullWidth - 1)) 209Dim start = _change.Span.Start 226If position < _change.Span.Start Then 230If position >= _change.Span.Start + _change.NewLength Then 389Dim range = New TextSpan(_affectedRange.Span.Start, _affectedRange.NewLength) 440If _curNodeSpan.Contains(_affectedRange.Span.Start) Then
Scanner\Directives.vb (1)
544startSkipped = skippedSpan.Start
Scanner\Scanner.vb (2)
348If span.Start >= 0 AndAlso span.End <= _bufferLen Then 349Return SyntaxFactory.DisabledTextTrivia(GetTextNotInterned(span.Start, span.Length))
Symbols\LexicalSortKey.vb (9)
101Me.New(syntaxRef.SyntaxTree, syntaxRef.Span.Start, compilation) 114Debug.Assert(location.PossiblyEmbeddedOrMySourceSpan.Start >= 0) 129Me._position = location.PossiblyEmbeddedOrMySourceSpan.Start 188Return first.PossiblyEmbeddedOrMySourceSpan.Start - second.PossiblyEmbeddedOrMySourceSpan.Start 201Return first.Span.Start - second.Span.Start 214Return first.Span.Start - second.Span.Start
Symbols\Source\SourceMemberContainerTypeSymbol.vb (14)
1370Return containingSourceNamespace.GetDeclarationSpelling(firstLocation.SourceTree, firstLocation.SourceSpan.Start) 1580Debug.Assert(initializer.Syntax.Span.Start > initializers.Last().Syntax.Span.Start) 2254((fileCompResult = 0) AndAlso typeToTestLocation.SourceSpan.Start >= structBeingAnalyzedLocation.SourceSpan.Start) 3253If Me._declaration.Declarations.Length >= 1 AndAlso position = Me._declaration.Declarations(0).Location.SourceSpan.Start Then 3284Dim distanceFromInitializerStart = position - siblingInitializers(index).Syntax.Span.Start 3307Dim index = initializers.BinarySearch(position, Function(initializer, pos) initializer.Syntax.Span.Start.CompareTo(pos)) 3885If GetImplementsLocation(interface1).SourceSpan.Start > GetImplementsLocation(interface2).SourceSpan.Start Then 3935If GetImplementsLocation(interface1).SourceSpan.Start > GetImplementsLocation(interface2).SourceSpan.Start Then 3967If GetImplementsLocation(interface1).SourceSpan.Start > GetImplementsLocation(interface2).SourceSpan.Start Then
Symbols\Source\SourceMethodSymbol.vb (1)
1217Return localPosition - span.Start
Symbols\Source\SourcePropertySymbol.vb (2)
165Dim accessor = If(getMethod.Locations(0).SourceSpan.Start < setMethod.Locations(0).SourceSpan.Start, setMethod, getMethod)
Symbols\Symbol.vb (1)
314Dim token = CType(location.SourceTree.GetRoot().FindToken(location.SourceSpan.Start), SyntaxToken)
Syntax\SyntaxFacts.vb (1)
1116If p.GetLocation.SourceSpan.Start < token.SpanStart Then
Syntax\SyntaxNodeRemover.vb (8)
54Dim start As Integer = span0.Start 60start = Math.Min(start, span.Start) 244Dim fullSpan = TextSpan.FromBounds(token.FullSpan.Start, node.FullSpan.End) 245Dim span = TextSpan.FromBounds(token.Span.Start, node.Span.End) 268Dim fullSpan = TextSpan.FromBounds(node.FullSpan.Start, token.FullSpan.End) 269Dim span = TextSpan.FromBounds(node.Span.Start, token.Span.End) 290removedSpan = TextSpan.FromBounds(span.Start, removedSpan.End) 293removedSpan = TextSpan.FromBounds(removedSpan.Start, span.End)
Syntax\SyntaxReplacer.vb (2)
120start = span.Start 123start = Math.Min(start, span.Start)
Syntax\VisualBasicLineDirectiveMap.vb (1)
210Dim unmappedStartPos = sourceText.Lines.GetLinePosition(span.Start)
Syntax\VisualBasicSyntaxNode.vb (1)
158''' Same as accessing <see cref="TextSpan.Start"/> on <see cref="Span"/>.
Syntax\VisualBasicSyntaxTree.vb (1)
435Return New FileLinePositionSpan(Me.FilePath, GetLinePosition(span.Start), GetLinePosition(span.End))
Microsoft.CodeAnalysis.VisualBasic.CodeStyle (11)
BaseFormattingRule.vb (1)
64Return TextSpan.FromBounds(spanStart, trivia.FullSpan.Start)
ParenthesizedExpressionSyntaxExtensions.vb (2)
141If interpolation.OpenBraceToken.Span.End = node.OpenParenToken.Span.Start AndAlso 142node.OpenParenToken.Span.End = expression.Span.Start Then
SyntaxNodeExtensions.vb (2)
415If Not textSpan.Contains(matchSpan.Start) Then 593If position < span.Start Then
SyntaxTreeExtensions.vb (2)
128If (child.FullSpan.Start < position) AndAlso (position <= child.FullSpan.End) Then 283If trivia.Span.Start > position Then
TriviaDataFactory.TriviaRewriter.vb (1)
86Return TextSpan.FromBounds(_node.FullSpan.Start, pair.Item2.SpanStart)
VisualBasicSyntaxFacts.vb (3)
814firstStatement.FullSpan.Start, 815method.EndBlockStatement.FullSpan.Start) 859Return outerSpan.Contains(innerSpan.Start)
Microsoft.CodeAnalysis.VisualBasic.CodeStyle.Fixes (6)
SpecialFormattingOperation.vb (1)
71TextSpan.FromBounds(startToken.FullSpan.Start, node.FullSpan.End), indentationDelta:=1, [option]:=IndentBlockOption.RelativePosition))
SyntaxTreeExtensions.vb (1)
550position = possibleTuple.FullSpan.Start
VisualBasicConvertToIteratorCodeFixProvider.vb (1)
58Dim symbol = model.GetEnclosingSymbol(node.Span.Start, cancellationToken)
VisualBasicIndentationService.Indenter.vb (3)
63Dim line = indenter.Text.Lines.GetLineFromPosition(trivia.FullSpan.Start) 64If line.GetFirstNonWhitespacePosition() = trivia.FullSpan.Start Then 65Return New IndentationResult(trivia.FullSpan.Start, 0)
Microsoft.CodeAnalysis.VisualBasic.EditorFeatures (3)
EndConstructGeneration\VisualBasicEndConstructGenerationService.vb (1)
306Dim aligningWhitespace = subjectBuffer.CurrentSnapshot.GetAligningWhitespace(state.TokenToLeft.Parent.Span.Start)
LineCommit\CommitBufferManager.vb (1)
190finalSpanStart = Math.Min(finalSpanStart, startingStatementInfo.TextSpan.Start)
LineCommit\CommitCommandHandler.vb (1)
109Dim selectedSpan = New SnapshotSpan(snapshot, textspan.Start, textspan.Length)
Microsoft.CodeAnalysis.VisualBasic.EditorFeatures.UnitTests (13)
CommentSelection\VisualBasicCommentSelectionTests.vb (1)
85SetupSelection(doc.GetTextView(), spans.Select(Function(s) Span.FromBounds(s.Start, s.End)))
Diagnostics\Suppression\SuppressionAllCodeTests.vb (1)
42Dim member = VisualBasicSyntaxFacts.Instance.GetContainingMemberDeclaration(n, n.Span.Start)
EditAndContinue\BreakpointSpansTests.vb (3)
61source.Substring(expectedSpan.Value.Start, expectedSpan.Value.Length), 63source.Substring(breakpointSpan.Start, breakpointSpan.Length))) 81itemInspector:=Function(span) "[|" & source.Substring(span.Start, span.Length) & "|]")
EditAndContinue\VisualBasicEditAndContinueAnalyzerTests.vb (2)
44Dim expectedText As String = source.Substring(expectedSpan.Start, expectedSpan.Length) 52Dim actualText = source.Substring(actualSpan.Start, actualSpan.Length)
LineCommit\CommitWithViewTests.vb (1)
790Dim snapshotspan = New SnapshotSpan(testData.Buffer.CurrentSnapshot, New Span(onlyTextSpan.Start, onlyTextSpan.Length))
LineSeparators\LineSeparatorTests.vb (1)
296Return spans.OrderBy(Function(span) span.Start)
SimplifyTypeNames\SimplifyTypeNamesTests.vb (3)
1825Assert.NotEqual(span.Start, 0) 1873Assert.Equal(span.Start, expected.Value.ToString.Replace(vbLf, vbCrLf).IndexOf("new C", StringComparison.Ordinal) + 4) 1907Assert.Equal(span.Start, expected.Value.ToString.Replace(vbLf, vbCrLf).IndexOf("Console.WriteLine(""goo"")", StringComparison.Ordinal))
TypeInferrer\TypeInferrerTests.vb (1)
49Dim token = root.FindToken(textSpan.Start)
Microsoft.CodeAnalysis.VisualBasic.Features (64)
CodeFixes\GenerateEndConstruct\GenerateEndConstructCodeFixProvider.vb (1)
67Dim token = root.FindToken(context.Span.Start)
CodeFixes\GenerateEvent\GenerateEventCodeFixProvider.vb (1)
47Dim token = root.FindToken(context.Span.Start)
CodeFixes\GenerateParameterizedMember\GenerateParameterizedMemberCodeFixProvider.vb (2)
63If node.Span.Start = diagnosticSpan.Start AndAlso node.Span.End < diagnosticSpan.End Then
CodeFixes\IncorrectExitContinue\IncorrectExitContinueCodeFixProvider.vb (1)
64Dim token = root.FindToken(span.Start)
CodeFixes\IncorrectFunctionReturnType\IncorrectFunctionReturnTypeCodeFixProvider.vb (1)
47Dim token = root.FindToken(span.Start)
CodeFixes\MoveToTopOfFile\MoveToTopOfFileCodeFixProvider.vb (1)
49Dim token = root.FindToken(span.Start)
CodeFixes\OverloadBase\OverloadBaseCodeFixProvider.vb (1)
42Dim token = root.FindToken(diagnosticSpan.Start)
CodeRefactorings\VisualBasicRefactoringHelpersService.vb (1)
36position <= typeDecl.EndBlockStatement.Span.Start Then
Completion\KeywordRecommenders\PreprocessorDirectives\PreprocessorHelpers.vb (1)
45If child.FullSpan.Start > _maxPosition Then
Debugging\BreakpointResolver.vb (1)
32Dim token = tree.GetRoot(cancellationToken).FindToken(location.SourceSpan.Start)
Debugging\VisualBasicBreakpointService.vb (1)
77Return GetBreakpointAsync(document, textSpan.Start, textSpan.Length, cancellationToken)
Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.vb (4)
119If _ignoredSpans IsNot Nothing AndAlso _ignoredSpans.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) Then 131If _ignoredSpans IsNot Nothing AndAlso _ignoredSpans.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) Then 143If _ignoredSpans IsNot Nothing AndAlso _ignoredSpans.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) Then 175If _ignoredSpans IsNot Nothing AndAlso _ignoredSpans.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) Then
EditAndContinue\BreakpointSpans.vb (4)
70If candidate.HasValue AndAlso breakpointSpan.Value.Start <> candidate.Value.Start Then 250Return TextSpan.FromBounds(node.Identifier.Span.Start, node.Initializer.Span.End) 254Return TextSpan.FromBounds(node.Identifier.Span.Start, node.AsClause.Span.End)
EditAndContinue\VisualBasicEditAndContinueAnalyzer.vb (7)
397Return (TextSpan.FromBounds(propertyStatement.Identifier.Span.Start, propertyStatement.Initializer.Span.End), Nothing) 401Return (TextSpan.FromBounds(propertyStatement.Identifier.Span.Start, propertyStatement.AsClause.Span.End), Nothing) 445Return (envelope:=TextSpan.FromBounds(declaration.Span.Start, asNewClause.NewExpression.Span.End), 446hole:=TextSpan.FromBounds(declaration.Span.End, asNewClause.NewExpression.Span.Start)) 499Dim position = span.Start 1680Return TextSpan.FromBounds(newWith.NewKeyword.Span.Start, 1742Return TextSpan.FromBounds(ifKeyword.Span.Start,
ExtractMethod\VisualBasicMethodExtractor.Analyzer.vb (1)
73Dim info = semanticModel.GetSpeculativeTypeInfo(Me.SelectionResult.FinalSpan.Start, SyntaxFactory.ParseName(symbol.Name), SpeculativeBindingOption.BindAsExpression)
ExtractMethod\VisualBasicMethodExtractor.vb (1)
31Dim originalSpanStart = OriginalSelectionResult.OriginalSpan.Start
ExtractMethod\VisualBasicSelectionValidator.vb (6)
250Dim start = If(selectionInfo.OriginalSpan.Start <= firstToken.SpanStart, selectionInfo.OriginalSpan.Start, firstToken.FullSpan.Start) 294Dim startPosition = symbol.Locations.First().SourceSpan.Start 470Dim firstTokenInSelection = root.FindTokenOnRightOfPosition(adjustedSpan.Start, includeSkipped:=False) 662Return TextSpan.FromBounds(textSpan.Start, previousLine.End)
GenerateDefaultConstructors\VisualBasicGenerateDefaultConstructorsService.vb (2)
33If headerFacts.IsOnTypeHeader(semanticDocument.Root, textSpan.Start, typeDecl) Then 38Dim token = semanticDocument.Root.FindToken(textSpan.Start)
GoToDefinition\VisualBasicGoToDefinitionSymbolService.vb (3)
29Return FindContainingReturnableConstruct(node).GetFirstToken().Span.Start 34Return continueTarget.GetFirstToken().Span.Start 44Return Symbol.Locations.FirstOrNone().SourceSpan.Start
Highlighting\KeywordHighlightingHelpers.vb (1)
96highlights(index) = TextSpan.FromBounds(span.Start, .AwaitKeyword.Span.End)
ImplementInterface\VisualBasicImplementInterfaceCodeFixProvider.vb (1)
44Dim token = root.FindToken(span.Start)
InlineHints\VisualBasicInlineParameterNameHintsService.vb (1)
56buffer.Add((argument.Span.Start, argumentIdentifier, parameter, GetKind(argument.Expression)))
SignatureHelp\AbstractIntrinsicOperatorSignatureHelpProvider.vb (1)
106currentSpan.Start = node.SpanStart Then
SignatureHelp\AttributeSignatureHelpProvider.vb (2)
98currentSpan.Start = SignatureHelpUtilities.GetSignatureHelpSpan(expression.ArgumentList).Start Then
SignatureHelp\CollectionInitializerSignatureHelpProvider.vb (2)
79currentSpan.Start = GetSignatureHelpSpan(expression).Start Then
SignatureHelp\FunctionAggregationSignatureHelpProvider.vb (1)
36functionAggregation.SpanStart = currentSpan.Start Then
SignatureHelp\GenericNameSignatureHelpProvider.vb (2)
36currentSpan.Start = SignatureHelpUtilities.GetSignatureHelpSpan(expression.TypeArgumentList).Start Then
SignatureHelp\InvocationExpressionSignatureHelpProvider.vb (2)
37currentSpan.Start = GetSignatureHelpSpan(expression.ArgumentList).Start Then
SignatureHelp\ObjectCreationExpressionSignatureHelpProvider.vb (2)
36currentSpan.Start = SignatureHelpUtilities.GetSignatureHelpSpan(expression.ArgumentList).Start Then
SignatureHelp\RaiseEventStatementSignatureHelpProvider.vb (1)
35currentSpan.Start = statement.Name.SpanStart Then
Snippets\VisualBasicSnippetFunctionService.vb (2)
31Dim token = syntaxTree.FindTokenOnRightOfPosition(switchExpressionSpan.Start, cancellationToken) 47Dim typeSpan = New TextSpan(caseGenerationLocation.Start + "Case ".Length, fullyQualifiedTypeName.Length)
Structure\Providers\DisabledTextTriviaStructureProvider.vb (1)
21Dim startPos = nodeSpan.Start
Structure\Providers\DocumentationCommentStructureProvider.vb (1)
28Dim startPos = firstCommentToken.Value.FullSpan.Start
Structure\Providers\XmlExpressionStructureProvider.vb (2)
26Dim line = syntaxTree.GetText(cancellationToken).Lines.GetLineFromPosition(span.Start) 27Dim lineText = line.ToString().Substring(span.Start - line.Start)
TaskList\VisualBasicTaskListService.vb (1)
30AppendTaskListItemsOnSingleLine(commentDescriptors, document, commentTrivia.ToFullString(), commentTrivia.FullSpan.Start, items)
VisualBasicConvertToIteratorCodeFixProvider.vb (1)
58Dim symbol = model.GetEnclosingSymbol(node.Span.Start, cancellationToken)
Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests (43)
Compilation\SemanticModelAPITests.vb (1)
2913Dim conv2 = model.ClassifyConversion(castNode.Span.Start, expr, castType)
Compilation\SemanticModelGetDeclaredSymbolAPITests.vb (34)
1258paramSymbol1.Locations.Single().SourceSpan.Start) 1266paramSymbol2.Locations.Single().SourceSpan.Start - "Optional ".Length) 1274paramSymbol3.Locations.Single().SourceSpan.Start) 1282paramSymbol4.Locations.Single().SourceSpan.Start) 1290paramSymbol5.Locations.Single().SourceSpan.Start) 1369Assert.Equal(syntax.SpanStart + 6, paramSymbol1.Locations.Single().SourceSpan.Start) 1374Assert.Equal(syntax.SpanStart + 6, paramSymbol2.Locations.Single().SourceSpan.Start) 1379Assert.Equal(syntax.SpanStart, paramSymbol3.Locations.Single().SourceSpan.Start) 1384Assert.Equal(syntax.SpanStart + 6, paramSymbol4.Locations.Single().SourceSpan.Start) 1849Assert.True(syntax.SpanStart = tpSymbol1.Locations.Item(0).SourceSpan.Start OrElse 1850syntax.SpanStart = tpSymbol1.Locations.Item(1).SourceSpan.Start, 1858Assert.True(syntax.SpanStart = tpSymbol2.Locations.Item(0).SourceSpan.Start OrElse 1859syntax.SpanStart = tpSymbol2.Locations.Item(1).SourceSpan.Start, 1867Assert.True(syntax.SpanStart = tpSymbol3.Locations.Item(0).SourceSpan.Start OrElse 1868syntax.SpanStart = tpSymbol3.Locations.Item(1).SourceSpan.Start, 1876Assert.True(syntax.SpanStart = tpSymbol4.Locations.Item(0).SourceSpan.Start OrElse 1877syntax.SpanStart = tpSymbol4.Locations.Item(1).SourceSpan.Start, 1885Assert.Equal(syntax.SpanStart, tpSymbol5.Locations.Single().SourceSpan.Start) 2022Assert.True(syntax.SpanStart = varSymbol1.Locations.Item(0).SourceSpan.Start OrElse 2023syntax.SpanStart = varSymbol1.Locations.Item(1).SourceSpan.Start, 2032Assert.True(syntax.SpanStart = varSymbol2.Locations.Item(0).SourceSpan.Start OrElse 2033syntax.SpanStart = varSymbol2.Locations.Item(1).SourceSpan.Start, 2042Assert.True(syntax.SpanStart = varSymbol3.Locations.Item(0).SourceSpan.Start OrElse 2043syntax.SpanStart = varSymbol3.Locations.Item(1).SourceSpan.Start, 2052Assert.True(syntax.SpanStart = varSymbol4.Locations.Item(0).SourceSpan.Start OrElse 2053syntax.SpanStart = varSymbol4.Locations.Item(1).SourceSpan.Start, 2062Assert.True(syntax.SpanStart = varSymbol5.Locations.Item(0).SourceSpan.Start OrElse 2063syntax.SpanStart = varSymbol5.Locations.Item(1).SourceSpan.Start, 2072Assert.True(syntax.SpanStart = varSymbol6.Locations.Item(0).SourceSpan.Start OrElse 2073syntax.SpanStart = varSymbol6.Locations.Item(1).SourceSpan.Start, 2083Assert.True(syntax.SpanStart = varSymbol7.Locations.Item(0).SourceSpan.Start OrElse 2084syntax.SpanStart = varSymbol7.Locations.Item(1).SourceSpan.Start, 2093Assert.True(syntax.SpanStart = varSymbol8.Locations.Item(0).SourceSpan.Start OrElse 2094syntax.SpanStart = varSymbol8.Locations.Item(1).SourceSpan.Start,
Compilation\SuppressAccessibilityChecksTests.vb (6)
56Dim position = invocation.FullSpan.Start 71Dim position = invocation.FullSpan.Start 82Dim position = invocation.FullSpan.Start 194Dim position = invocation.FullSpan.Start 262speculativeModel.GetSpeculativeSymbolInfo(privateCandidate.FullSpan.Start, privateCandidate, 266speculativeModel.GetSpeculativeTypeInfo(privateCandidate.FullSpan.Start, privateCandidate,
FlowAnalysis\FlowTestBase.vb (2)
173Dim startToken As SyntaxToken = tree.GetCompilationUnitRoot().FindToken(region.Start, True) 175While startToken.Span.End <= region.Start
Microsoft.CodeAnalysis.VisualBasic.Symbol.UnitTests (1)
SymbolsTests\Source\MethodTests.vb (1)
1699Assert.Equal(operatorPos, span.Start)
Microsoft.CodeAnalysis.VisualBasic.Syntax.UnitTests (78)
LocationTests.vb (2)
73Dim xToEndClassSpan As New TextSpan(xSpan.Start, sampleProgram.IndexOf("End Class", StringComparison.Ordinal) - xSpan.Start + 3)
Parser\ParseExpression.vb (1)
1022errors &= e.Code & " : " & e.GetMessage(CultureInfo.GetCultureInfo("en")) & " (" & span.Start & ", " & span.End & ")" & Environment.NewLine
Parser\ParseIteratorTests.vb (1)
365Order By expression.FullSpan.Start
Scanner\ScanConditionalTests.vb (11)
21Assert.Equal(0, res.Start) 44Assert.Equal(0, res.Start) 57Assert.Equal(12, res.Start) 80Assert.Equal(0, res.Start) 89Assert.Equal(12, res.Start) 97Assert.Equal(20, res.Start) 120Assert.Equal(0, res.Start) 129Assert.Equal(9, res.Start) 138Assert.Equal(19, res.Start) 147Assert.Equal(31, res.Start) 156Assert.Equal(40, res.Start)
Scanner\ScannerTests.vb (24)
217Assert.Equal(trivia.Span.Start, 16) 222Assert.Equal(trivia.Span.Start, 18) 260Assert.Equal(trivia2.Span.Start, 16) 265Assert.Equal(trivia3.Span.Start, 18) 270Assert.Equal(trivia4.Span.Start, 33) 327Assert.Equal(trivia.Span.Start, 19) 332Assert.Equal(trivia.Span.Start, 21) 370Assert.Equal(trivia2.Span.Start, 19) 375Assert.Equal(trivia3.Span.Start, 21) 380Assert.Equal(trivia4.Span.Start, 36) 404Assert.Equal(trivia.Span.Start, 22) 409Assert.Equal(trivia.Span.Start, 24) 458Assert.Equal(trivia.Span.Start, 16) 463Assert.Equal(trivia.Span.Start, 18) 501Assert.Equal(trivia2.Span.Start, 16) 506Assert.Equal(trivia3.Span.Start, 18) 511Assert.Equal(trivia4.Span.Start, 33) 568Assert.Equal(trivia.Span.Start, 19) 573Assert.Equal(trivia.Span.Start, 21) 611Assert.Equal(trivia2.Span.Start, 19) 616Assert.Equal(trivia3.Span.Start, 21) 621Assert.Equal(trivia4.Span.Start, 36) 645Assert.Equal(trivia.Span.Start, 22) 650Assert.Equal(trivia.Span.Start, 24)
TestSyntaxNodes.vb (39)
222Assert.Equal(expectedFullSpan.Start, list(0).FullSpan.Start) 228Assert.Equal(list(i - 1).FullSpan.End, list(i).FullSpan.Start) 231Assert.Equal(list(i).FullSpan.End, list(i + 1).FullSpan.Start) 244Assert.Equal(expectedFullSpan.Start, list(0).FullSpan.Start) 250Assert.Equal(list(i).FullSpan.End, list(i + 1).FullSpan.Start) 266Assert.Equal(expectedFullSpan.Start, list(0).FullSpan.Start) 272Assert.Equal(list(i - 1).FullSpan.End, list(i).FullSpan.Start) 275Assert.Equal(list(i).FullSpan.End, list(i + 1).FullSpan.Start) 290Assert.Equal(expectedFullSpan.Start, list(0).FullSpan.Start) 296Assert.Equal(list(i - 1).FullSpan.End, list(i).FullSpan.Start) 299Assert.Equal(list(i).FullSpan.End, list(i + 1).FullSpan.Start) 309Assert.Equal(expectedFullSpan.Start, list(0).FullSpan.Start) 315Assert.Equal(list(i).FullSpan.End, list(i + 1).FullSpan.Start) 334Assert.Equal(tree.SpanStart, tree.FullSpan.Start) 336VerifyListSpans(precedingTrivia, New TextSpan(tree.FullSpan.Start, (tree.SpanStart - tree.FullSpan.Start))) 359Assert.Equal(tree.SpanStart, tree.FullSpan.Start) 361VerifyListSpans(precedingTrivia, New TextSpan(tree.FullSpan.Start, (tree.SpanStart - tree.FullSpan.Start))) 411VerifyListSpans(statements, TextSpan.FromBounds(statements(0).FullSpan.Start, statements(statements.Count - 1).FullSpan.End)) 595Assert.Equal(start, seplist(0).FullSpan.Start) 685Assert.Equal(0, tok.FullSpan.Start) 701Assert.Equal(0, tok.FullSpan.Start) 709Assert.Equal(1, follTrivia(0).FullSpan.Start) 715Assert.Equal(4, follTrivia(1).FullSpan.Start) 728Assert.Equal(0, tok.FullSpan.Start) 740Assert.Equal(0, precTrivia(0).FullSpan.Start) 746Assert.Equal(4, precTrivia(1).FullSpan.Start) 752Assert.Equal(6, precTrivia(2).FullSpan.Start) 761Assert.Equal(10, follTrivia(0).FullSpan.Start) 934Dim i = span1.Start.CompareTo(span2.Start) 2264Dim position = identifier.Span.Start + 1 2298invalidSpan = New TextSpan(classDecl2.FullSpan.Start - 1, root.FullSpan.End)
Microsoft.CodeAnalysis.VisualBasic.Test.Utilities (10)
CompilationTestUtils.vb (5)
996Dim lineText As String = GetLineText(sourceLocation.SourceTree.GetText(), sourceLocation.SourceSpan.Start, offsetInLine) 1043If loc1.SourceSpan.Start < loc2.SourceSpan.Start Then Return -1 1044If loc1.SourceSpan.Start > loc2.SourceSpan.Start Then Return 1
ParserTestUtilities.vb (3)
465<%= If(e.Location.IsInSource, New XAttribute("start", e.Location.SourceSpan.Start), Nothing) %> 565output.AppendLine(GetErrorString(e.Code, e.GetMessage(EnsureEnglishUICulture.PreferredOrNull), span.Start.ToString(), span.End.ToString())) 617If spanStart IsNot Nothing AndAlso CInt(spanStart) <> syntaxErrorSpan.Start Then
SemanticModelTestBase.vb (2)
90" Location1.SourceSpan.Start : " & tpSymbol.Locations.Item(0).SourceSpan.Start & 91" Location2.SourceSpan.Start : " & tpSymbol.Locations.Item(0).SourceSpan.Start
Microsoft.CodeAnalysis.VisualBasic.Workspaces (39)
Classification\ClassificationHelpers.vb (1)
323Dim tokens = SyntaxFactory.ParseTokens(text2, initialTokenPosition:=textSpan.Start)
Classification\Worker.DocumentationCommentClassifier.vb (3)
25If childFullSpan.Start > _worker._textSpan.End Then 27ElseIf childFullSpan.End < _worker._textSpan.Start Then 92spanStart = trivia.Span.Start + index
CodeCleanup\Providers\AbstractTokensCodeCleanupProvider.vb (1)
57_spans.GetIntervalsThatOverlapWith(node.FullSpan.Start, node.FullSpan.Length).Any()
CodeCleanup\Providers\AddMissingTokensCodeCleanupProvider.vb (2)
335_spans.HasIntervalThatContains(span.Start, span.Length) AndAlso 452If Not _spans.HasIntervalThatContains(span.Start, span.Length) Then
CodeCleanup\Providers\NormalizeModifiersOrOperatorsCodeCleanupProvider.vb (5)
93Not _spans.HasIntervalThatOverlapsWith(node.FullSpan.Start, node.FullSpan.Length) Then 203If Not _spans.HasIntervalThatContains(span.Start, span.Length) Then 243If Not _spans.HasIntervalThatContains(span.Start, span.Length) Then 272If Not _spans.HasIntervalThatContains(span.Start, span.Length) Then 455If Not _spans.HasIntervalThatContains(span.Start, span.Length) Then
CodeGeneration\VisualBasicCodeGenerationService.vb (3)
385Return Cast(Of TDeclarationNode)(AppendTriviaAtPosition(newMember, positionOfRemovedNode - destination.FullSpan.Start, triviaOfRemovedNode)) 395Return Cast(Of TDeclarationNode)(AppendTriviaAtPosition(newCompilationUnit, positionOfRemovedNode - destination.FullSpan.Start, triviaOfRemovedNode)) 404Return Cast(Of TDeclarationNode)(AppendTriviaAtPosition(newParameter, positionOfRemovedNode - destination.FullSpan.Start, triviaOfRemovedNode))
Formatting\Engine\Trivia\TriviaDataFactory.TriviaRewriter.vb (1)
86Return TextSpan.FromBounds(_node.FullSpan.Start, pair.Item2.SpanStart)
Formatting\Rules\BaseFormattingRule.vb (1)
64Return TextSpan.FromBounds(spanStart, trivia.FullSpan.Start)
J\s\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxTreeExtensions.vb\SyntaxTreeExtensions.vb (2)
128If (child.FullSpan.Start < position) AndAlso (position <= child.FullSpan.End) Then 283If trivia.Span.Start > position Then
J\s\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\ContextQuery\SyntaxTreeExtensions.vb\SyntaxTreeExtensions.vb (1)
550position = possibleTuple.FullSpan.Start
OrganizeImports\VisualBasicOrganizeImportsService.Rewriter.vb (2)
75Return TextSpan.FromBounds(list.First().FullSpan.Start, list.Last().FullSpan.[End]) 79Return TextSpan.FromBounds(list.First().FullSpan.Start, list.Last().FullSpan.[End])
ParenthesizedExpressionSyntaxExtensions.vb (2)
141If interpolation.OpenBraceToken.Span.End = node.OpenParenToken.Span.Start AndAlso 142node.OpenParenToken.Span.End = expression.Span.Start Then
Rename\VisualBasicRenameRewriterLanguageService.vb (5)
97newSpan = New TextSpan(oldSpan.Start, newSpan.Length) 237Me._renameSpansTracker.AddComplexifiedSpan(Me._documentId, oldSpan, New TextSpan(oldSpan.Start, newSpan.Length), Me._modifiedSubSpans) 295AddModifiedSpan(annotation.OriginalSpan, New TextSpan(token.Span.Start, newToken.Span.Length)) 304Dim symbols = RenameUtilities.GetSymbolsTouchingPosition(token.Span.Start, _semanticModel, _solution.Services, _cancellationToken) 817implicitReferenceLocation.Location.SourceSpan.Start, cancellationToken, findInsideTrivia:=False).ConfigureAwait(False)
Simplification\Simplifiers\AbstractVisualBasicSimplifier.vb (1)
172boundSymbols = semanticModel.LookupNamespacesAndTypes(node.Span.Start, name:=aliasName + "Attribute")
SpecialFormattingOperation.vb (1)
71TextSpan.FromBounds(startToken.FullSpan.Start, node.FullSpan.End), indentationDelta:=1, [option]:=IndentBlockOption.RelativePosition))
SyntaxNodeExtensions.vb (2)
415If Not textSpan.Contains(matchSpan.Start) Then 593If position < span.Start Then
VisualBasicIndentationService.Indenter.vb (3)
63Dim line = indenter.Text.Lines.GetLineFromPosition(trivia.FullSpan.Start) 64If line.GetFirstNonWhitespacePosition() = trivia.FullSpan.Start Then 65Return New IndentationResult(trivia.FullSpan.Start, 0)
VisualBasicSyntaxFacts.vb (3)
814firstStatement.FullSpan.Start, 815method.EndBlockStatement.FullSpan.Start) 859Return outerSpan.Contains(innerSpan.Start)
Microsoft.CodeAnalysis.VisualBasic.Workspaces.UnitTests (2)
EmbeddedLanguages\VirtualChars\VisualBasicVirtualCharServiceTests.vb (2)
33For i = ch.Span.Start To ch.Span.End - 1 91Return $"[{ConvertToString(ChrW(vc.Rune.Value))},[{vc.Span.Start - _statementPrefix.Length},{vc.Span.End - _statementPrefix.Length}]]"
Microsoft.CodeAnalysis.Workspaces (268)
AbstractCodeGenerationService.cs (3)
506positionOfRemovedNode = attributeList.FullSpan.Start; 526positionOfRemovedNode = attributeToRemove.FullSpan.Start; 528var previousToken = root.FindToken(attributeToRemove.FullSpan.Start - 1);
AbstractFileBannerFacts.cs (3)
154(node.FullSpan.Start == 0 && _fileBannerMatcher.TryMatch(leadingTriviaToKeep, ref index))) 166Debug.Assert(root.FullSpan.Start == 0); 172Debug.Assert(firstToken.FullSpan.Start == 0);
AbstractFormattingResult.cs (2)
83var oldText = (change.Span == span) ? originalString : originalString.Substring(change.Span.Start - span.Start, change.Span.Length);
AbstractHeaderFacts.cs (3)
59if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 81if (tokenToRightOrIn.FullSpan.Start != position && tokenToRightOrIn.RawKind != SyntaxFacts.SyntaxKinds.EndOfFileToken) 97return Math.Min(afterAttributesToken.Span.Start, node.Span.End);
AbstractIndentation.Indenter.cs (1)
248=> Math.Min(Root.EndOfFileToken.FullSpan.Start, position);
AbstractMoveDeclarationNearReferenceService.State.cs (1)
107let token = syntaxRoot.FindToken(r.Location.SourceSpan.Start)
AbstractSelectedMembers.cs (3)
66? root.FindToken(textSpan.Start) 67: root.FindTokenOnRightOfPosition(textSpan.Start); 126var position = textSpan.Start;
AbstractTriviaFormatter.cs (5)
488if (ContainsOnlyWhitespace(firstToken.FullSpan.Start, firstToken.SpanStart)) 502for (var i = span.Start - this.Token1.Span.End; i < span.Length; i++) 836return TextSpan.FromBounds(this.StartPosition, trivia2.FullSpan.Start); 844return TextSpan.FromBounds(trivia1.FullSpan.End, trivia2.FullSpan.Start); 938var offset = trivia.FullSpan.Start - this.StartPosition;
AbstractVirtualCharService.cs (5)
86Debug.Assert(currentVC.Span.Start >= token.SpanStart, "First span has to start after the start of the string token"); 90Debug.Assert(currentVC.Span.Start == token.SpanStart + 1 || 91currentVC.Span.Start == token.SpanStart + 2, "First span should start on the second or third char of the string."); 99Debug.Assert(currentVC.Span.End <= nextVC.Span.Start, "Virtual character spans have to be ordered."); 108Debug.Assert(currentVC.Span.End == nextVC.Span.Start, "Virtual character spans have to be touching.");
AnchorIndentationOperation.cs (1)
19Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);
BaseIndentationFormattingRule.cs (9)
131=> TextSpan.FromBounds(Math.Max(_span.Start, textSpan.Start), Math.Min(_span.End, textSpan.End)); 152token1 = root.FindToken(span.Start); 157if (span.End < token1.Span.Start) 162if (token2.Span.End < span.Start) 177if (span.Start <= token1.Span.Start) 190var end = token2.Span.Start; 196end = token2.Span.Start;
BKTree.Builder.cs (2)
195_concatenatedLowerCaseWords.AsSpan(currentNode.CharacterSpan.Start, currentNode.CharacterSpan.Length), 196_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length));
BKTree.cs (2)
124_concatenatedLowerCaseWords.AsSpan(characterSpan.Start, characterSpan.Length), 130result.Add(new string(_concatenatedLowerCaseWords, characterSpan.Start, characterSpan.Length));
BKTree.Node.cs (1)
36writer.WriteInt32(WordSpan.Start);
BottomUpBaseIndentationFinder.cs (2)
59if (token.Span.End <= operation.TextSpan.Start && 337if (operation.TextSpan.IsEmpty && operation.TextSpan.Start == position)
Classification\ClassifiedSpanIntervalIntrospector.cs (1)
19=> value.TextSpan.Start;
Classification\Classifier.cs (4)
87allClassifications.Sort((s1, s2) => s1.TextSpan.Start - s2.TextSpan.Start); 99return ConvertClassificationsToParts(sourceText, textSpan.Start, classifiedSpans); 110if (startPosition < span.TextSpan.Start)
Classification\ClassifierHelper.cs (13)
115FillInClassifiedSpanGaps(widenedSpan.Start, mergedSpans, filledInSpans); 119private static readonly Comparison<ClassifiedSpan> s_spanComparison = static (s1, s2) => s1.TextSpan.Start - s2.TextSpan.Start; 148if (!isAdditiveClassification && previousSpan.TextSpan.End > intersection.Value.Start) 174if (startPosition < span.TextSpan.Start) 178startPosition, span.TextSpan.Start))); 220syntacticPart.TextSpan.Start, syntacticPart.TextSpan.Length, ref tempBuffer.AsRef()); 240if (syntacticPart.TextSpan.Start < firstSemanticPart.TextSpan.Start) 243syntacticPart.TextSpan.Start, 244firstSemanticPart.TextSpan.Start))); 255if (semanticPart1.TextSpan.End < semanticPart2.TextSpan.Start) 259semanticPart2.TextSpan.Start)));
Classification\IRemoteSemanticClassificationService.cs (1)
81classificationTriples.Add(textSpan.Start);
Classification\SyntaxClassification\SyntacticChangeRangeComputer.cs (6)
133Contract.ThrowIfFalse(currentOld.FullSpan.Start == currentNew.FullSpan.Start); 142return currentOld.FullSpan.Start; 147return currentOld.FullSpan.Start; 203currentOld.FullSpan.Start >= commonLeftWidth && 204currentNew.FullSpan.Start >= commonLeftWidth)
CodeCleanup\AbstractCodeCleanerService.cs (2)
367startToken = root.FindToken(span.Start, findInsideTrivia: true); 386startToken = FindTokenOnLeftOfPosition(root, span.Start);
CodeFixes\FixAllOccurrences\BatchFixAllProvider.cs (1)
122.ThenBy(d => d.Location.SourceSpan.Start)
CodeFixes\FixAllOccurrences\TextChangeMerger.cs (5)
23int IIntervalIntrospector<TextChange>.GetStart(TextChange value) => value.Span.Start; 72var changesToApply = _totalChangesIntervalTree.Distinct().OrderBy(tc => tc.Span.Start); 105change.Span.Start, change.Span.Length, ref overlappingSpans); 108change.Span.Start, change.Span.Length, ref intersectingSpans); 190otherChange.Span.End == change.Span.Start;
CodeGenerationHelpers.cs (1)
206var afterMember = declarationList.LastOrDefault(m => m.SpanStart <= info.Context.AfterThisLocation.SourceSpan.Start);
CommonFormattingHelpers.cs (13)
20return o1.TextSpan.Start - o2.TextSpan.Start; 26var s = o1.TextSpan.Start - o2.TextSpan.Start; 83var startToken = root.FindToken(textSpan.Start); 93if (textSpan.Start < startToken.SpanStart) 139return root.FullSpan.End == startToken.SpanStart || startToken.FullSpan.End > endToken.FullSpan.Start; 181if (token1.FullSpan.End == token2.FullSpan.Start) 189for (var token = token1.GetNextToken(includeZeroWidth: true); token.FullSpan.End <= token2.FullSpan.Start; token = token.GetNextToken(includeZeroWidth: true)) 300var forwardPosition = token.FullSpan.Start; 308Contract.ThrowIfFalse(parentNode.FullSpan.Start < forwardPosition); 324if (fullSpan.Start < position) 364var startToken = root.FindToken(span.Start).GetPreviousToken();
Differencing\Edit.cs (1)
116=> "@" + _comparer.GetSpan(node).Start;
DocumentExtensions.cs (1)
119var token = root.FindToken(span.Start);
Editing\ImportAdderService.cs (1)
48Func<SyntaxNode, bool> overlapsWithSpan = n => spansTree.HasIntervalThatOverlapsWith(n.FullSpan.Start, n.FullSpan.Length);
Editing\SymbolEditor.cs (1)
330return EditOneDeclarationAsync(symbol, doc.Id, location.SourceSpan.Start, editAction, cancellationToken);
EditorConfigFile.cs (2)
47.ThenByDescending(x => x.section.Span.Start) 85.ThenByDescending(x => x.section.Span.Start) // in event of a further tie, pick entry at the bottom of the file
EmbeddedSyntaxHelpers.cs (1)
19=> TextSpan.FromBounds(firstChar.Span.Start, lastChar.Span.End);
EmbeddedSyntaxNode.cs (2)
85return span.Value.Start; 118start = Math.Min(token.VirtualChars[0].Span.Start, start);
EmbeddedSyntaxToken.cs (3)
82Math.Min(LeadingTrivia.Length == 0 ? int.MaxValue : LeadingTrivia[0].GetSpan().Start, 83Math.Min(VirtualChars.Length == 0 ? int.MaxValue : VirtualChars[0].Span.Start, 84TrailingTrivia.Length == 0 ? int.MaxValue : TrailingTrivia[0].GetSpan().Start));
FindSymbols\FindReferences\FindReferenceCache.cs (1)
147if (span.Start == index && span.Length == identifier.Length && IsMatch(token))
FindSymbols\ReferenceLocationExtensions.cs (1)
73var enclosingSymbol = semanticModel.GetEnclosingSymbol(reference.Location.SourceSpan.Start);
FindSymbols\TopLevelSyntaxTree\DeclaredSymbolInfo.cs (1)
197writer.WriteInt32(Span.Start);
FormattingContext.AnchorData.cs (3)
44=> value.TextSpan.Start; 50=> value.TextSpan.Start; 56=> value.InseparableRegionSpan.Start;
FormattingContext.cs (12)
162if (operationSpan.Start < baseSpan.Start || 208var inseparableRegionStartingPosition = effectiveBaseTokenGetter(this, operation).FullSpan.Start; 227var indentationData = _indentationTree.GetSmallestContainingInterval(operation.TextSpan.Start, 0); 436var intervals = tree.GetIntervalsThatContain(textSpan.Start, textSpan.Length); 473var indentationData = _relativeIndentationTree.GetSmallestContainingInterval(span.Start, 0); 495var anchorData = _anchorTree.GetSmallestContainingInterval(span.Start, 0); 499DebugCheckEmpty(_anchorTree, new TextSpan(span.Start, 0)); 566var anchorData = _anchorTree.GetIntervalsThatOverlapWith(baseAnchorData.TextSpan.Start, baseAnchorData.TextSpan.Length); 624var data = _suppressWrappingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 653var data = _suppressSpacingTree.GetSmallestEdgeExclusivelyContainingInterval(textSpan.Start, textSpan.Length); 675=> _suppressFormattingTree.HasIntervalThatIntersectsWith(textSpan.Start, textSpan.Length);
FormattingContext.IndentationData.cs (1)
120return new RelativeIndentationData(_formattingContext, InseparableRegionSpan.Start, span, Operation, _effectiveBaseTokenGetter, _indentationDeltaGetter, _baseIndentationGetter, _lazyIndentationDelta);
FormattingExtensions.cs (2)
278span = new TextSpan(span.Start + i, span.Length - i); 340last = TextSpan.FromBounds(last.Start, span.End);
IndentBlockOperation.cs (3)
19Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 39Contract.ThrowIfFalse(baseToken.Span.End <= textSpan.Start); 41Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);
ISyntaxFactsExtensions.cs (2)
166var span = TextSpan.FromBounds(nodes.First().Span.Start, nodes.Last().Span.End); 461var startOfNodeWithoutAttributes = Math.Min(afterAttributesToken.Span.Start, endOfNode);
J\s\src\Compilers\Core\Portable\Syntax\SyntaxTreeExtensions.cs\SyntaxTreeExtensions.cs (1)
67index += span.Start;
J\s\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTreeExtensions.cs\SyntaxTreeExtensions.cs (1)
103var startLineNumber = text.Lines.IndexOf(span.Start);
LanguageServices\FixAllSpanMappingService\AbstractFixAllSpanMappingService.cs (3)
56var partialDeclSpan = syntaxFacts.GetContainingTypeDeclaration(root, syntaxRef.Span.Start)!.FullSpan; 80? syntaxFacts.GetContainingMemberDeclaration(root, span.Start) 81: syntaxFacts.GetContainingTypeDeclaration(root, span.Start);
LinkedFileDiffMerging\AbstractLinkedFileMergeConflictCommentAdditionService.cs (3)
45var changeStartLine = originalSourceText.Lines.GetLineFromPosition(change.Span.Start); 70var startPosition = changePartition.First().Span.Start; 77var adjustedChanges = changePartition.Select(c => new TextChange(TextSpan.FromBounds(c.Span.Start - startLineStartPosition, c.Span.End - startLineStartPosition), c.NewText));
LinkedFileDiffMerging\LinkedFileDiffMergingSession.cs (11)
148while (cumulativeChangeIndex < cumulativeChanges.Count && cumulativeChanges[cumulativeChangeIndex].Span.End < change.Span.Start) 240while (commentChangeIndex < commentChangesList.Count && commentChangesList[commentChangeIndex].Span.End <= mergedChange.Span.Start) 244mergeConflictResolutionSpans.Add(new TextSpan(commentChangesList[commentChangeIndex].Span.Start + currentPositionDelta, commentChangesList[commentChangeIndex].NewText.Length)); 249if (commentChangeIndex >= commentChangesList.Count || mergedChange.Span.End <= commentChangesList[commentChangeIndex].Span.Start) 258var conflictingCommentInsertionLocation = new TextSpan(mergedChange.Span.Start, 0); 259while (commentChangeIndex < commentChangesList.Count && commentChangesList[commentChangeIndex].Span.Start < mergedChange.Span.End) 262mergeConflictResolutionSpans.Add(new TextSpan(commentChangesList[commentChangeIndex].Span.Start + currentPositionDelta, commentChangesList[commentChangeIndex].NewText.Length)); 277mergeConflictResolutionSpans.Add(new TextSpan(commentChangesList[commentChangeIndex].Span.Start + currentPositionDelta, commentChangesList[commentChangeIndex].NewText.Length)); 296changes = changes.OrderBy(c => c.Span.Start); 302if (nextChange.Span.Start == currentChange.Span.End) 304currentChange = new TextChange(TextSpan.FromBounds(currentChange.Span.Start, nextChange.Span.End), currentChange.NewText + nextChange.NewText);
LocationExtensions.cs (2)
20=> location.GetSourceTreeOrThrow().GetRoot(cancellationToken).FindToken(location.SourceSpan.Start); 39return !(tree == null || tree.IsHiddenPosition(loc.SourceSpan.Start));
NamingStyle.cs (8)
177=> name.Substring(wordSpan.Start, wordSpan.Length); 179private static readonly Func<string, TextSpan, bool> s_firstCharIsLowerCase = (val, span) => !DoesCharacterHaveCasing(val[span.Start]) || char.IsLower(val[span.Start]); 180private static readonly Func<string, TextSpan, bool> s_firstCharIsUpperCase = (val, span) => !DoesCharacterHaveCasing(val[span.Start]) || char.IsUpper(val[span.Start]); 184for (int i = span.Start, n = span.End; i < n; i++) 197for (int i = span.Start, n = span.End; i < n; i++) 410newWords[i] = name[parts[i].Start..parts[i].End];
NamingStyle.WordSpanEnumerator.cs (1)
27Current = new TextSpan(nameSpan.Start, 0);
NormalizedTextSpanCollection.cs (17)
96if (span1.Start < span2.Start) 286if ((span2.Length == 0) || (span1.Start >= span2.End)) 290else if (span1.End <= span2.Start) 296spans.Add(TextSpan.FromBounds(Math.Max(lastEnd, span1.Start), span1.End)); 302if (span1.Start < span2.Start) 306Debug.Assert(lastEnd < span2.Start); 307spans.Add(TextSpan.FromBounds(Math.Max(lastEnd, span1.Start), span2.Start)); 334spans.Add(TextSpan.FromBounds(Math.Max(lastEnd, span1.Start), span1.End)); 564if (end < span.Start) 574start = span.Start; 597sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); }); 601var oldStart = sorted[0].Start; 605var newStart = sorted[i].Start;
PatternMatching\AllLowerCamelCaseMatcher.cs (3)
107if (ToLower(_candidate[candidateHump.Start], _textInfo) == patternCharacter) 173_candidate, candidateHump.Start, 202var matchSpanToAdd = new TextSpan(candidateHump.Start, possibleHumpMatchLength);
PatternMatching\PatternMatcher.cs (8)
229var hump = TextSpan.FromBounds(candidateHumps[i].Start, candidateLength); 234matchedSpan: GetMatchedSpan(hump.Start, patternChunk.Text.Length)); 403candidate, candidatePart.Start, patternPart.Length, 404pattern, patternPart.Start, patternPart.Length, compareOptions) == 0; 537if (!char.IsUpper(patternChunk.Text[patternHumps[currentPatternHump - 1].Start]) || 538!char.IsUpper(patternChunk.Text[patternHumps[currentPatternHump].Start])) 549matchSpans.Add(new TextSpan(candidateHump.Start, patternChunkCharacterSpan.Length)); 559candidateHump = new TextSpan(candidateHump.Start + patternChunkCharacterSpan.Length, candidateHump.Length - patternChunkCharacterSpan.Length);
ReassignedVariable\AbstractReassignedVariableService.cs (1)
251if (current.SpanStart <= localOrParameterDeclarationSpan.Start)
Rename\ConflictEngine\ConflictResolver.cs (1)
415.ThenBy(l => l.IsInSource ? l.SourceSpan.Start : int.MaxValue);
Rename\ConflictEngine\ConflictResolver.Session.cs (12)
223renamedSpansTracker.GetAdjustedPosition(_renameSymbolDeclarationLocation.SourceSpan.Start, _documentIdOfRenameSymbolDeclaration), 419var baseToken = baseRoot.FindToken(conflictAnnotation.OriginalSpan.Start, true); 539var adjustedStartPosition = conflictResolution.GetAdjustedTokenStartingPosition(originalReference.TextSpan.Start, originalReference.DocumentId); 540if (newLocations.Any(loc => loc.SourceSpan.Start == adjustedStartPosition)) 589var newAdjustedStartPosition = conflictResolution.GetAdjustedTokenStartingPosition(renameDeclarationLocationReference.TextSpan.Start, renameDeclarationLocationReference.DocumentId); 590if (newAdjustedStartPosition != newLocation.SourceSpan.Start) 598var overridingSymbol = await SymbolFinder.FindSymbolAtPositionAsync(solution.GetRequiredDocument(newLocation.SourceTree), newLocation.SourceSpan.Start, cancellationToken: _cancellationToken).ConfigureAwait(false); 649var newReferencedSymbols = RenameUtilities.GetSymbolsTouchingPosition(tokenOrNode.Span.Start, newDocumentSemanticModel, newDocument.Project.Solution.Services, _cancellationToken); 676? conflictResolution.GetAdjustedTokenStartingPosition(_renameSymbolDeclarationLocation.SourceSpan.Start, _documentIdOfRenameSymbolDeclaration) 677: _renameSymbolDeclarationLocation.SourceSpan.Start; 896var offset = renameLocation.Location.SourceSpan.Start - containingLocationForStringOrComment.Start;
Rename\ConflictEngine\RenamedSpansTracker.cs (7)
57? _documentToModifiedSpansMap[documentId].Where(pair => pair.oldSpan.Start < startingPosition) : 67? _documentToComplexifiedSpansMap[documentId].Where(c => c.OriginalSpan.Start <= startingPosition) : 80foreach (var (oldSpan, newSpan) in c.ModifiedSubSpans.OrderByDescending(t => t.oldSpan.Start)) 84if (startingPosition == oldSpan.Start) 86return startingPosition + newSpan.Start - oldSpan.Start; 88else if (startingPosition > oldSpan.Start)
Rename\RenameUtilities.cs (3)
264Debug.Assert(subSpan.Start <= replaceInsideString.Length); 268if (replaceInsideString.Substring(subSpan.Start, subSpan.Length) != matchText) 272var offset = subSpan.Start - startOffset;
Rename\SymbolicRenameLocations.ReferenceProcessing.cs (2)
365.Select(t => Tuple.Create(t.ToString(), t.Span.Start, t.Span)); 383.Select(t => Tuple.Create(t.ToString(), t.Span.Start, t.Token.Span));
Shared\Extensions\SourceTextExtensions.cs (1)
41text.GetLineAndOffset(textSpan.Start, out startLineNumber, out startOffset);
Shared\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)
369if (p.Length > 0 && char.IsLetter(name[p.Start])) 370return name.Substring(p.Start, p.Length).ToCamelCase();
SimpleIntervalTreeExtensions.cs (1)
16=> tree.HasIntervalThatIntersectsWith(span.Start, span.Length);
Simplification\AbstractSimplificationService.cs (1)
106=> !spansTree.HasIntervalThatOverlapsWith(nodeOrToken.FullSpan.Start, nodeOrToken.FullSpan.Length);
SourceTextExtensions_SharedWithCodeStyle.cs (1)
48var startLineNumber = text.Lines.IndexOf(span.Start);
StringBreaker.cs (1)
33Debug.Assert(span.Start >= start, "Bad generator.");
SuppressIntervalIntrospector.cs (2)
14=> value.TextSpan.Start; 20=> value.TextSpan.Start;
SuppressOperation.cs (1)
17Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);
SymbolKey.SymbolKeyWriter.cs (1)
258WriteInteger(location.SourceSpan.Start);
SyntaxEditorBasedCodeFixProvider.cs (2)
45.Sort((d1, d2) => d1.Location.SourceSpan.Start - d2.Location.SourceSpan.Start);
SyntaxNodeExtensions.cs (2)
322Math.Min(fullSpan.Start, node.SpanStart), 689while (position <= token.SpanStart && root.FullSpan.Start < token.SpanStart);
TextChangeRangeExtensions.cs (19)
37var currentStart = accumulatedTextChangeSoFar.Value.Span.Start; 39var currentNewEnd = accumulatedTextChangeSoFar.Value.Span.Start + accumulatedTextChangeSoFar.Value.NewLength; 68if (newChange.Span.Start < currentStart) 70currentStart = newChange.Span.Start; 96currentNewEnd = newChange.Span.Start + newChange.NewLength; 161else if (newChange.SpanEnd <= oldChange.Span.Start + oldDelta) 179else if (newChange.SpanStart < oldChange.Span.Start + oldDelta) 198var newChangeLeadingDeletion = oldChange.Span.Start + oldDelta - newChange.SpanStart; 200newChange = new UnadjustedNewChange(oldChange.Span.Start + oldDelta, newChange.SpanLength - newChangeLeadingDeletion, newChange.NewLength); 203else if (newChange.SpanStart > oldChange.Span.Start + oldDelta) 221var oldChangeLeadingInsertion = newChange.SpanStart - (oldChange.Span.Start + oldDelta); 224addAndAdjustOldDelta(builder, ref oldDelta, new TextChangeRange(new TextSpan(oldChange.Span.Start, oldChangeLeadingDeletion), oldChangeLeadingInsertion)); 231Debug.Assert(newChange.SpanStart == oldChange.Span.Start + oldDelta); 310newChange = new UnadjustedNewChange(oldChange.Span.Start + oldDelta, newDeletion, newChange.NewLength); 387if (last.Span.End == change.Span.Start) 390builder[^1] = new TextChangeRange(new TextSpan(last.Span.Start, last.Span.Length + change.Span.Length), last.NewLength + change.NewLength); 393else if (last.Span.End > change.Span.Start) 429: this(range.Span.Start, range.Span.Length, range.NewLength) 434private static int NewEnd(this TextChangeRange range) => range.Span.Start + range.NewLength;
TextLineExtensions.cs (1)
71for (var i = line.Span.Start; i < line.Span.End; i++)
TextSpanExtensions.cs (8)
31if (span.Start < start) 33start = span.Start; 62var innerSpan = TextSpan.FromBounds(startNode.Span.Start, endNode.Span.End); 63var outerSpan = TextSpan.FromBounds(startNode.FullSpan.Start, endNode.FullSpan.End); 79var startSegmentEnd = Math.Min(span.End, except.Start); 80if (span.Start < startSegmentEnd) 81yield return TextSpan.FromBounds(span.Start, startSegmentEnd); 83var endSegmentStart = Math.Max(span.Start, except.End);
TextSpanIntervalIntrospector.cs (1)
12=> value.Start;
TokenStream.cs (1)
87Debug.Assert(previousToken.FullSpan.End <= currentToken.FullSpan.Start);
TreeData.cs (1)
62get { return this.Root.FullSpan.Start; }
TreeData.NodeAndText.cs (1)
38return _text.ToString(TextSpan.FromBounds(token2.FullSpan.Start, token2.SpanStart));
TreeData.StructuredTrivia.cs (1)
43var text = _trivia.ToFullString()[..(token.SpanStart - _trivia.FullSpan.Start)];
VirtualCharSequence.Chunks.cs (2)
52if (position < _array[0].Span.Start || position >= _array[^1].Span.End) 57if (position < ch.Span.Start)
VirtualCharSequence.cs (6)
56if (span.Start > sequence.Length) 74public VirtualChar this[int index] => _leafCharacters[_span.Start + index]; 87=> new(_leafCharacters, new TextSpan(_span.Start + span.Start, span.Length)); 197Debug.Assert(_span.End == virtualChars._span.Start); 211TextSpan.FromBounds(chars1._span.Start, chars2._span.End));
Microsoft.CodeAnalysis.Workspaces.Test.Utilities (1)
Formatting\FormattingTestBase.cs (1)
117if (span.Start == 0 && span.End == inputText.Length)
Microsoft.CodeAnalysis.Workspaces.UnitTests (29)
BatchFixAllProviderTests.cs (1)
126var token = root.FindToken(sourceSpan.Start);
EditorConfigParsing\EditorConfigFileParserTests.cs (19)
40Assert.Equal(10, section?.Span.Start); 44Assert.Equal(20, section?.Span.Start); 48Assert.Equal(30, section?.Span.Start); 80Assert.Equal(70, section?.Span.Start); 96Assert.Equal(70, section?.Span.Start); 100Assert.Equal(20, section?.Span.Start); 104Assert.Equal(40, section?.Span.Start); 122Assert.Equal(10, section?.Span.Start); 126Assert.Equal(20, section?.Span.Start); 161Assert.Equal(70, section?.Span.Start); 165Assert.Equal(40, section?.Span.Start); 180Assert.Equal(30, section?.Span.Start); 184Assert.Equal(40, section?.Span.Start); 206Assert.Equal(120, section?.Span.Start); 210Assert.Equal(130, section?.Span.Start); 223Assert.Equal(100, section?.Span.Start); 227Assert.Equal(60, section?.Span.Start); 239Assert.Equal(100, section?.Span.Start); 243Assert.Equal(0, section?.Span.Start);
Shared\Extensions\TextSpanExtensions\SubtractTests.cs (7)
32private static int RightBeforeStart(TextSpan span) => span.Start - 1; 33private static int AtStart(TextSpan span) => span.Start; 34private static int RightAfterStart(TextSpan span) => span.Start + 1; 295EmptySpan.Subtract(TextSpan.FromBounds(RightBeforeStart(EmptySpan), EmptySpan.Start))); 309EmptySpan.Subtract(TextSpan.FromBounds(EmptySpan.Start, EmptySpan.Start))); 316EmptySpan.Subtract(TextSpan.FromBounds(EmptySpan.Start, RightAfterEnd(EmptySpan))));
SymbolKeyTests.cs (2)
1362Assert.True(resolved.Symbol.Locations[0].SourceSpan.Start > symbol.Locations[0].SourceSpan.Start);
Microsoft.VisualStudio.IntegrationTest.Utilities (1)
InProcess\Editor_InProc.cs (1)
626return matchingTags.Select(t => t.Span.GetSpans(view.TextBuffer).Single().Span.ToTextSpan()).SelectMany(t => new List<int> { t.Start, t.Length }).ToArray();
Microsoft.VisualStudio.LanguageServices (58)
CodeLens\RemoteCodeLensReferencesService.cs (3)
194result.Span.Start, 218reference.Value.MappedSpan.Start, 233var mappedLine = lines.GetLineFromPosition(tooltip.Value.MappedSpan.Start);
FindReferences\Contexts\AbstractTableDataSourceFindUsagesContext.cs (2)
400return (result.Value, AbstractDocumentSpanEntry.GetLineContainingPosition(result.Value.Content, result.Value.MappedSpan.Start)); 414return (excerptResult, AbstractDocumentSpanEntry.GetLineContainingPosition(sourceText, documentSpan.SourceSpan.Start));
FindReferences\Contexts\WithoutReferencesFindUsagesContext.cs (1)
134var lineText = AbstractDocumentSpanEntry.GetLineContainingPosition(sourceText, documentSpan.SourceSpan.Start);
FindReferences\Entries\DocumentSpanEntry.cs (2)
176if (position == _excerptResult.MappedSpan.Start) 277var lineNumber = sourceText.Lines.GetLineFromPosition(referenceSpan.Start).LineNumber;
Implementation\AbstractVsTextViewFilter.cs (2)
213if (matchingSpan.Value.Start < position) 237var closingSpans = braceMatcher.FindMatchingSpanAsync(document, matchingSpan.Value.Start, options, cancellationToken).WaitAndGetResult(cancellationToken);
LanguageService\AbstractLanguageService`2.IVsLanguageTextOps.cs (1)
96start = prevToken.Span.Start;
ProjectSystem\TextEditApplication.cs (1)
42edit.Replace(change.Span.Start, change.Span.Length, change.NewText);
Snippets\AbstractSnippetCommandHandler.cs (2)
297if (!IsSnippetExpansionContext(document, span.Value.Start, cancellationToken)) 302return GetSnippetExpansionClient(textView, subjectBuffer).TryInsertExpansion(span.Value.Start, span.Value.End, cancellationToken);
ValueTracking\TreeItemViewModel.cs (4)
77sourceText.GetLineAndOffset(textSpan.Start, out var lineStart, out var _); 115var spanStartPosition = TextSpan.Start - ClassifiedSpans[0].TextSpan.Start; 129if (position == highlightSpan.Start || highlightSpan.Contains(position))
Venus\ContainedDocument.cs (32)
290if (change.Span.End < visibleSpan.Start) 296if (visibleSpan.End < change.Span.Start) 338if (change.Span.End <= visibleTextSpan.Start) 343if (visibleTextSpan.End <= change.Span.Start) 357var offsetInOriginalText = changeInOriginalText.Span.Start; 388var spanInOriginalText = new TextSpan(offsetInOriginalText + spanInLeftText.Start, spanInLeftText.Length); 511var visibleFirstLineInOriginalText = originalText.Lines.GetLineFromPosition(visibleSpanInOriginalText.Start); 522var snippetInRightText = rightText.Substring(spanInRightText.Start, spanInRightText.Length); 561if (spanInOriginalText.Start < visibleSpanInOriginalText.Start && 562visibleSpanInOriginalText.Start <= spanInOriginalText.End && 581if (visibleSpanInOriginalText.Start < spanInOriginalText.Start && 582spanInOriginalText.Start <= visibleSpanInOriginalText.End && 586if (spanInOriginalText.Start <= visibleLastLineInOriginalText.Start) 589TextSpan.FromBounds(spanInOriginalText.Start, visibleLastLineInOriginalText.Start), 713.OrderBy(s => s.Start); 737visibleSpansInOriginal[currentVisibleSpanIndex].End < change.Span.Start) 835var current = root.FindToken(visibleTextSpan.Start).Parent; 838if (current.Span.Start == visibleTextSpan.Start) 840var blockType = GetRazorCodeBlockType(visibleSpan.Start); 844return new BaseIndentationFormattingRule(root, TextSpan.FromBounds(visibleSpan.Start, end), baseIndentation, _vbHelperFormattingRule); 848if (current.Span.Start < visibleSpan.Start) 850var blockType = GetRazorCodeBlockType(visibleSpan.Start); 854return new BaseIndentationFormattingRule(root, TextSpan.FromBounds(visibleSpan.Start, end), baseIndentation, _vbHelperFormattingRule); 893var startingLine = text.Lines.GetLineFromPosition(span.Start); 916var start = visibleSpan.Start; 939var firstLine = text.Lines.GetLineFromPosition(visibleSpan.Start); 961var type = GetRazorCodeBlockType(span.Start); 978if (token.Span.Start == end && service != null)
Venus\ContainedDocument.DocumentServiceProvider.cs (3)
216if (spanOnContentSpan.Start < startPositionOnContentSpan) 319=> new(targetSpan.Start - excerptSpan.Start, targetSpan.Length);
Venus\ContainedLanguage.IVsContainedCode.cs (1)
64iStartLine = snapshot.GetLineNumberFromPosition(tuple.Item1.Start),
Venus\ContainedLanguageCodeSupport.cs (3)
211var position = type.Locations.First(loc => loc.SourceTree == targetSyntaxTree).SourceSpan.Start; 305? semanticModel.LookupSymbols(position: type.Locations[0].SourceSpan.Start, container: type, name: null) 502return semanticModel.LookupSymbols(typeLocation.SourceSpan.Start, objectType, nameOfEvent).SingleOrDefault(m => m.Kind == SymbolKind.Event);
Workspace\VisualStudioDocumentNavigationService.cs (1)
423=> TextSpan.FromBounds(GetPositionWithinDocumentBounds(span.Start, documentLength), GetPositionWithinDocumentBounds(span.End, documentLength));
Microsoft.VisualStudio.LanguageServices.CSharp (6)
CodeModel\CSharpCodeModelService.cs (2)
2878deletionStart = trivia.FullSpan.Start; 3202var startToken = root.FindToken(span.Start).GetPreviousToken();
LanguageService\CSharpHelpContextService.cs (4)
50var token = await syntaxTree.GetTouchingTokenAsync(span.Start, cancellationToken, findInsideTrivia: true).ConfigureAwait(false); 68var trivia = root.FindTrivia(span.Start, findInsideTrivia: true); 79var start = span.Start; 80var end = span.Start;
Microsoft.VisualStudio.LanguageServices.Implementation (3)
CodeModel\AbstractCodeModelService.cs (1)
625element = underlyingFileCodeModel.CodeElementFromPosition(chosenLocation!.SourceSpan.Start, GetElementKind(typeSymbol));
CodeModel\Collections\OverloadsCollection.cs (1)
82var element = fileCodeModel.CodeElementFromPosition(location.SourceSpan.Start, EnvDTE.vsCMElement.vsCMElementFunction);
CodeModel\Collections\PartialTypeCollection.cs (1)
65var element = fileCodeModel.CodeElementFromPosition(location.SourceSpan.Start, ParentType.Kind);
Microsoft.VisualStudio.LanguageServices.IntegrationTests (3)
CSharp\CSharpOutlining.cs (2)
51Assert.Equal(spans.OrderBy(s => s.Start), VisualStudio.Editor.GetOutliningSpans()); 92var expectedSpans = spans[""].Concat(spans[configuration]).OrderBy(s => s.Start);
VisualBasic\BasicOutlining.cs (1)
43Assert.Equal(spans.OrderBy(s => s.Start), VisualStudio.Editor.GetOutliningSpans());
Microsoft.VisualStudio.LanguageServices.LiveShare (1)
Client\RemoteLanguageServiceWorkspace.cs (1)
536edit.Replace(change.Span.Start, change.Span.Length, change.NewText);
Microsoft.VisualStudio.LanguageServices.New.IntegrationTests (2)
InProcess\EditorInProcess.cs (1)
196view.SetMultiSelection(positions.Select(p => new SnapshotSpan(subjectBuffer.CurrentSnapshot, p.Start, p.Length)));
InProcess\EditorVerifierInProcess.cs (1)
263Assert.Equal(expectedTag.textSpan.Start, actualTaggedSpan.Span.Start.Position);
Microsoft.VisualStudio.LanguageServices.UnitTests (43)
AbstractTextViewFilterTests.vb (23)
108TestSpan(workspace, doc, span.Start, span.End, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE)) 109TestSpan(workspace, doc, span.End, span.Start, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE)) 110TestSpan(workspace, doc, span.Start + 1, span.End, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE)) 111TestSpan(workspace, doc, span.End - 1, span.Start, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE)) 140TestSpan(workspace, doc, caretPosition:=span.Start, startPosition:=span.Start, endPosition:=span.End, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE_EXT)) 141TestSpan(workspace, doc, caretPosition:=doc.CursorPosition.Value, startPosition:=span.End, endPosition:=span.Start, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE_EXT)) 172TestSpan(workspace, doc, caretPosition:=span.Start, startPosition:=span.Start, endPosition:=span.End - 1, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE_EXT)) 173TestSpan(workspace, doc, caretPosition:=span.Start + 1, startPosition:=span.Start, endPosition:=span.End - 1, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE_EXT)) 176TestSpan(workspace, doc, caretPosition:=span.End, startPosition:=span.End - 1, endPosition:=span.Start, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE_EXT)) 177TestSpan(workspace, doc, caretPosition:=span.End - 1, startPosition:=span.End - 1, endPosition:=span.Start, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE_EXT)) 205TestSpan(workspace, doc, span.Start, span.End, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE)) 206TestSpan(workspace, doc, span.End, span.Start, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE)) 207TestSpan(workspace, doc, span.Start + 1, span.End, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE)) 208TestSpan(workspace, doc, span.End - 1, span.Start, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE)) 238TestSpan(workspace, doc, caretPosition:=span.Start, startPosition:=span.Start, endPosition:=span.End - 1, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE_EXT)) 239TestSpan(workspace, doc, caretPosition:=span.Start + 1, startPosition:=span.Start, endPosition:=span.End - 1, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE_EXT)) 242TestSpan(workspace, doc, caretPosition:=span.End, startPosition:=span.End - 1, endPosition:=span.Start, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE_EXT)) 243TestSpan(workspace, doc, caretPosition:=span.End - 1, startPosition:=span.End - 1, endPosition:=span.Start, commandId:=CUInt(VSConstants.VSStd2KCmdID.GOTOBRACE_EXT))
Debugging\VisualBasicBreakpointResolutionServiceTests.vb (2)
33source.Substring(expectedSpan.Value.Start, expectedSpan.Value.Length), 35source.Substring(result.TextSpan.Start, result.TextSpan.Length)))
Snippets\SnippetExpansionClientTestsHelper.vb (5)
20Dim snippetStartLine = surfaceBufferDocument.GetTextBuffer().CurrentSnapshot.GetLineFromPosition(snippetSpanInSurfaceBuffer.Start) 21Dim snippetEndLine = surfaceBufferDocument.GetTextBuffer().CurrentSnapshot.GetLineFromPosition(snippetSpanInSurfaceBuffer.Start) 25.iStartIndex = snippetSpanInSurfaceBuffer.Start - snippetStartLine.Start.Position, 71Dim snippetStartLine = document.GetTextBuffer().CurrentSnapshot.GetLineFromPosition(snippetSpan.Start) 76.iStartIndex = snippetSpan.Start - snippetStartLine.Start.Position,
Venus\DocumentService_IntegrationTests.vb (5)
89(definitionDocument.Name, definitionText.Lines.GetLinePositionSpan(definitionSpan).Start, definitionText.Lines.GetLineFromPosition(definitionSpan.Start).ToString().Trim()), 90(definitionDocument.Name, definitionText.Lines.GetLinePositionSpan(referenceSpan).Start, definitionText.Lines.GetLineFromPosition(referenceSpan.Start).ToString().Trim())} 154Dim expected = {(definitionDocument.Name, definitionText.Lines.GetLinePositionSpan(referenceSpan).Start, definitionText.Lines.GetLineFromPosition(referenceSpan.Start).ToString())} 325Dim line = mappedSource.Lines.GetLineFromPosition(mappedSpan.Start) 326Return New ExcerptResult(mappedSource.GetSubText(line.Span), New TextSpan(mappedSpan.Start - line.Start, mappedSpan.Length), ImmutableArray.Create(New ClassifiedSpan(New TextSpan(0, line.Span.Length), ClassificationTypeNames.Text)), document, span)
Venus\DocumentServiceTests.vb (8)
44Assert.Equal(projectedDocument.CursorPosition.Value, spans(0).Span.Start) 70Assert.Equal(projectedDocument.CursorPosition.Value, spans(0).Span.Start) 76Assert.Equal(projectedDocument.CursorPosition.Value + 1, spans(2).Span.Start) 156Dim actualFormatted = result.Value.ClassifiedSpans.Select(Function(a) New FormattedClassification(content.Substring(a.TextSpan.Start, a.TextSpan.Length), a.ClassificationType)) 195Dim actualFormatted = result.Value.ClassifiedSpans.Select(Function(a) New FormattedClassification(content.Substring(a.TextSpan.Start, a.TextSpan.Length), a.ClassificationType)) 250Dim actualFormatted = result.Value.ClassifiedSpans.Select(Function(a) New FormattedClassification(content.Substring(a.TextSpan.Start, a.TextSpan.Length), a.ClassificationType)) 255Assert.Equal(New TextSpan(documentSpan.Start - contentSpan.Start, documentSpan.Length), result.Value.MappedSpan) 294Dim actualFormatted = result.Value.ClassifiedSpans.Select(Function(a) New FormattedClassification(content.Substring(a.TextSpan.Start, a.TextSpan.Length), a.ClassificationType))
Microsoft.VisualStudio.LanguageServices.VisualBasic (4)
CodeModel\VisualBasicCodeModelService.vb (2)
1298deletionStart = trivia.FullSpan.Start 3732Dim startToken = GetTokenWithoutAnnotation(root.FindToken(span.Start).GetPreviousToken(), Function(t) t.GetPreviousToken())
Help\VisualBasicHelpContextService.vb (2)
41Dim token = tree.GetRoot(cancellationToken).FindToken(span.Start, findInsideTrivia:=True) 53Dim trivia = tree.GetRoot(cancellationToken).FindTrivia(span.Start, findInsideTrivia:=True)
Microsoft.VisualStudio.LanguageServices.Xaml (1)
Features\DocumentSpan.cs (1)
26return $"{Document.Name} [{TextSpan.Start}...{TextSpan.End}]";
Roslyn.Test.PdbUtilities (1)
Reader\PdbValidation.cs (1)
656var methodStart = methodStartTags[0].MatchedSpan.Start;