VirtualChar

5 instantiations of VirtualChar

Microsoft.CodeAnalysis.CSharp.EditorFeatures2.UnitTests (1)

EmbeddedLanguages\RegularExpressions\CSharpRegexParserTests.cs (1)

379Assert.True(RegexLexer.IsEscapeCategoryChar(new(new(ch, offset: 0, width: 1), tokenStart: 0)));

Microsoft.CodeAnalysis.Workspaces (4)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharGreenSequence.Chunks.cs (3)

41if (position < new VirtualChar(array[0], tokenStart).Span.Start || 42position >= new VirtualChar(array[^1], tokenStart).Span.End) 50var span = new VirtualChar(ch, tokenStart).Span;

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

142=> new(_sequence[index], _tokenStart);

170 references to VirtualChar

Microsoft.CodeAnalysis.CSharp.Features (32)

ConvertBetweenRegularAndVerbatimString\AbstractConvertBetweenRegularAndVerbatimStringCodeRefactoringProvider.cs (5)

106foreach (var ch in chars) 117static bool ShouldDouble(VirtualChar ch, bool isInterpolation) 129private static bool IsOpenOrCloseBrace(VirtualChar ch) 138foreach (var ch in chars) 174foreach (var ch in chars)

ConvertToRawString\ConvertRegularStringToRawStringCodeRefactoringProvider.cs (10)

188foreach (var ch in characters) 220var ch = characterList[i]; 250private static ImmutableSegmentedList<VirtualChar> ToSegmentedList(VirtualCharSequence characters) 252var result = ImmutableSegmentedList.CreateBuilder<VirtualChar>(); 253foreach (var ch in characters) 259private static ImmutableSegmentedList<VirtualChar> CleanupWhitespace(VirtualCharSequence characters) 274return ImmutableSegmentedList<VirtualChar>.Empty; 279var result = ImmutableSegmentedList.CreateBuilder<VirtualChar>(); 302private static void AddRange(ImmutableSegmentedList<VirtualChar>.Builder result, VirtualCharSequence sequence) 304foreach (var c in sequence)

ConvertToRawString\ConvertToRawStringHelpers.cs (5)

30public static bool IsCSharpNewLine(VirtualChar ch) 33public static bool IsCSharpWhitespace(VirtualChar ch) 46public static bool AllEscapesAre(VirtualCharSequence sequence, Func<VirtualChar, bool> predicate) 50foreach (var ch in sequence) 89var ch = characters[i];

EmbeddedLanguages\CSharpTestEmbeddedLanguageClassifier.cs (12)

27private static TextSpan FromBounds(VirtualChar vc1, VirtualChar vc2) 103ImmutableSegmentedList<VirtualChar> virtualCharsWithoutMarkup, CancellationToken cancellationToken) 131private static ImmutableSegmentedList<VirtualChar> StripMarkupCharacters( 134var builder = ImmutableSegmentedList.CreateBuilder<VirtualChar>(); 141var vc1 = virtualChars[i]; 142var vc2 = i + 1 < n ? virtualChars[i + 1] : default; 175var vc3 = i + 2 < n ? virtualChars[i + 2] : default; 210var colonChar = virtualChars[seekPoint]; 228ImmutableSegmentedList<VirtualChar> virtualChars, 267private readonly ImmutableSegmentedList<VirtualChar> _virtualChars; 271public VirtualCharSequenceSourceText(ImmutableSegmentedList<VirtualChar> virtualChars, Encoding? encoding)

Microsoft.CodeAnalysis.CSharp.Workspaces (2)

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

317public override bool TryGetEscapeCharacter(VirtualChar ch, out char escapedChar)

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

12public static bool TryGetEscapeCharacter(this VirtualChar ch, out char escapedChar)

Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests (5)

EmbeddedLanguages\VirtualChars\CSharpVirtualCharServiceTests.cs (5)

56foreach (var ch in virtualChars) 83foreach (var ch in virtualChars) 89private static string ConvertToString(VirtualChar vc) 92private static string ConvertRuneToString(VirtualChar c) 97private static bool PrintAsUnicodeEscape(VirtualChar c)

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (2)

EmbeddedLanguages\StackFrame\StackFrameParserTests.Utilities.cs (2)

97List<VirtualChar> enumeratedParsedCharacters = []; 101foreach (var ch in charSeq)

Microsoft.CodeAnalysis.ExternalAccess.AspNetCore (10)

EmbeddedLanguages\AspNetCoreVirtualChar.cs (9)

14internal readonly VirtualChar VirtualChar; 16internal AspNetCoreVirtualChar(VirtualChar virtualChar) 33/// <inheritdoc cref="VirtualChar.Span"/> 36/// <inheritdoc cref="VirtualChar.Value"/> 39/// <inheritdoc cref="VirtualChar.ToString"/> 42/// <inheritdoc cref="VirtualChar.Equals(object)"/> 45/// <inheritdoc cref="VirtualChar.Equals(VirtualChar)"/> 48/// <inheritdoc cref="VirtualChar.GetHashCode"/>

EmbeddedLanguages\AspNetCoreVirtualCharSequence.cs (1)

39public AspNetCoreVirtualChar? Find(int position) => (_virtualCharSequence.Find(position) is VirtualChar c) ? new(c) : null;

Microsoft.CodeAnalysis.Features (77)

EmbeddedLanguages\Classification\AbstractFallbackEmbeddedLanguageClassifier.cs (1)

47foreach (var vc in virtualChars)

EmbeddedLanguages\DateAndTime\EmbeddedCompletionContext.cs (1)

62foreach (var ch in virtualChars)

EmbeddedLanguages\Json\JsonLexer.cs (7)

31public readonly VirtualChar CurrentChar => Text[Position]; 87var openChar = this.CurrentChar; 93var currentCh = this.CurrentChar; 130var currentCh = this.CurrentChar; 146var ch = this.CurrentChar; 161private static bool IsHexDigit(VirtualChar c) 175static bool IsNotPartOfText(VirtualChar ch)

EmbeddedLanguages\Json\JsonParser.cs (3)

25/// Parser used for reading in a sequence of <see cref="VirtualChar"/>s, and producing a <see 490var firstChar = token.VirtualChars[0]; 543private static bool IsDigit(VirtualChar ch)

EmbeddedLanguages\Json\JsonParser.JsonNetSyntaxChecks.cs (5)

68var firstChar = chars[0]; 121foreach (var c in chars) 150foreach (var vc in nameToken.VirtualChars) 192foreach (var ch in textToken.VirtualChars) 201private static bool IsLegalPropertyNameChar(VirtualChar ch)

EmbeddedLanguages\Json\JsonParser.StrictSyntaxChecker.cs (1)

92foreach (var ch in trivia.VirtualChars)

EmbeddedLanguages\Json\LanguageServices\JsonBraceMatcher.cs (4)

64var ch = virtualChar.Value; 70private static BraceMatchingResult? FindBraceHighlights(JsonTree tree, VirtualChar ch) 73private static BraceMatchingResult? FindBraceMatchingResult(JsonNode node, VirtualChar ch) 112private static bool Matches(JsonToken openToken, JsonToken closeToken, VirtualChar ch)

EmbeddedLanguages\RegularExpressions\LanguageServices\RegexBraceMatcher.cs (12)

62var ch = virtualChar.Value; 76private static BraceMatchingResult? FindCommentBraces(RegexTree tree, VirtualChar ch) 82var firstChar = trivia.Value.VirtualChars[0]; 83var lastChar = trivia.Value.VirtualChars[^1]; 89private static BraceMatchingResult? FindGroupingBraces(RegexTree tree, VirtualChar ch) 95private static BraceMatchingResult? FindCharacterClassBraces(RegexTree tree, VirtualChar ch) 101private static RegexGroupingNode? FindGroupingNode(RegexNode node, VirtualChar ch) 105private static RegexBaseCharacterClassNode? FindCharacterClassNode(RegexNode node, VirtualChar ch) 109private static TNode? FindNode<TNode>(RegexNode node, VirtualChar ch, Func<TNode, VirtualChar, bool> predicate) 128private static RegexTrivia? FindTrivia(RegexNode node, VirtualChar ch) 152private static RegexTrivia? TryGetTrivia(ImmutableArray<RegexTrivia> triviaList, VirtualChar ch)

EmbeddedLanguages\RegularExpressions\LanguageServices\RegexDocumentHighlighter.cs (3)

75var ch = virtualChar.Value; 79private static ImmutableArray<HighlightSpan> FindReferenceHighlights(RegexTree tree, VirtualChar ch) 126private static RegexEscapeNode? FindReferenceNode(RegexNode node, VirtualChar virtualChar)

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

172var previousVirtualChar = previousVirtualCharOpt.Value; 247EmbeddedCompletionContext context, RegexTree tree, VirtualChar previousVirtualChar) 255var escapeChar = tree.Text[index - 1]; 392RegexNode parent, VirtualChar ch) 416private static bool IsInCharacterClass(RegexNode start, VirtualChar ch)

EmbeddedLanguages\RegularExpressions\RegexCharClass.cs (1)

189public static bool IsBoundaryWordChar(VirtualChar r)

EmbeddedLanguages\RegularExpressions\RegexHelpers.cs (2)

40public static char MapEscapeChar(VirtualChar ch) 58var ch = node.TypeToken.VirtualChars[0];

EmbeddedLanguages\RegularExpressions\RegexLexer.cs (10)

21/// Produces tokens from the sequence of <see cref="VirtualChar"/> characters. Unlike the 47public readonly VirtualChar CurrentChar => Position < Text.Length ? Text[Position] : default; 63var ch = this.CurrentChar; 69private static RegexKind GetKind(VirtualChar ch) 215private static bool IsBlank(VirtualChar ch) 253public static bool IsEscapeCategoryChar(VirtualChar ch) 346private static bool IsOptionChar(VirtualChar ch) 399public static bool IsHexChar(VirtualChar ch) 404private static bool IsDecimalDigit(VirtualChar ch) 407private static bool IsOctalDigit(VirtualChar ch)

EmbeddedLanguages\RegularExpressions\RegexParser.CaptureInfoAnalyzer.cs (1)

142var lastChar = grouping.CloseParenToken.IsMissing

EmbeddedLanguages\RegularExpressions\RegexParser.cs (10)

25/// Produces a <see cref="RegexTree"/> from a sequence of <see cref="VirtualChar"/> characters. 342var startCharacter = startTextNode.TextToken.VirtualChars[0]; 343var lastCharacter = startTextNode.TextToken.VirtualChars[^1]; 1203foreach (var ch in optionsToken.VirtualChars) 1227private static RegexOptions OptionFromCode(VirtualChar ch) 1425foreach (var vc in hexText.VirtualChars) 1435private static int HexValue(VirtualChar ch) 1500var nextChar = _currentToken.VirtualChars[0]; 1644var ch = _currentToken.VirtualChars[0]; 1833var ch = _currentToken.VirtualChars[0];

EmbeddedLanguages\StackFrame\StackFrameLexer.cs (8)

49foreach (var c in text) 58public readonly VirtualChar CurrentChar => Position < Text.Length ? Text[Position] : default; 89var ch = CurrentChar; 128var ch = Text[Position]; 383public static bool IsBlank(VirtualChar ch) 399private static bool IsAsciiAlphaCharacter(VirtualChar ch) 504private static StackFrameKind GetKind(VirtualChar ch) 535private static bool IsNumber(VirtualChar ch)

SpellCheck\AbstractSpellCheckSpanService.cs (3)

154var currentChar = virtualChars[currentCharIndex]; 167var endChar = virtualChars[currentCharIndex]; 194static bool IsWordPart(VirtualChar ch)

Microsoft.CodeAnalysis.Workspaces (42)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSyntaxHelpers.cs (2)

18public static TextSpan GetSpan(VirtualChar firstChar, VirtualChar lastChar)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSyntaxNode.cs (1)

125public bool Contains(VirtualChar virtualChar)

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

16public abstract bool TryGetEscapeCharacter(VirtualChar ch, out char escapedChar); 85var currentVC = result[0]; 98var nextVC = result[i]; 107var nextVC = result[i]; 113var lastVC = result[^1];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\IVirtualCharService.cs (3)

29/// Takes in a string token and return the <see cref="VirtualChar"/>s corresponding to each 50/// VirtualChar's <see cref="VirtualChar.Span"/> will abut each other, and the union of all of them will cover the 67bool TryGetEscapeCharacter(VirtualChar ch, out char escapeChar);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualChar.cs (5)

63/// <see cref="VirtualChar"/> provides a uniform view of a language's string token characters regardless if they 67/// (<c>\</c> and <c>t</c>). <see cref="VirtualChar"/> will represent both, providing the raw <see cref="char"/> 90public static implicit operator char(VirtualChar ch) 104public static bool operator ==(VirtualChar ch1, char ch2) 107public static bool operator !=(VirtualChar ch1, char ch2)

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

14/// Abstraction over a contiguous chunk of <see cref="VirtualChar"/>s. This 15/// is used so we can expose <see cref="VirtualChar"/>s over an <see cref="ImmutableArray{VirtualChar}"/>

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

75/// Gets the <see cref="VirtualChar"/> at the specified index. 141public VirtualChar this[int index] 145/// Returns the index of the <see cref="VirtualChar"/> in this <see cref="VirtualCharSequence"/> that contains the 181public struct Enumerator(VirtualCharSequence virtualCharSequence) : IEnumerator<VirtualChar> 186public readonly VirtualChar Current => virtualCharSequence[_position]; 198public static VirtualChar? Find(this VirtualCharSequence sequence, int position) 208public static bool Contains(this VirtualCharSequence sequence, VirtualChar @char) 211public static int IndexOf(this VirtualCharSequence sequence, VirtualChar @char) 214foreach (var ch in sequence) 231foreach (var ch in sequence) 237public static string CreateString(this ImmutableSegmentedList<VirtualChar> sequence) 240foreach (var ch in sequence) 246public static VirtualChar? FirstOrNull(this VirtualCharSequence sequence, Func<VirtualChar, bool> predicate) 248foreach (var ch in sequence) 257public static VirtualChar? LastOrNull(this VirtualCharSequence sequence, Func<VirtualChar, bool> predicate) 261var ch = sequence[i]; 269public static bool Any(this VirtualCharSequence sequence, Func<VirtualChar, bool> predicate) 271foreach (var ch in sequence) 280public static bool All(this VirtualCharSequence sequence, Func<VirtualChar, bool> predicate) 282foreach (var ch in sequence) 291public static VirtualCharSequence SkipWhile(this VirtualCharSequence sequence, Func<VirtualChar, bool> predicate) 294foreach (var ch in sequence)