VirtualChar

2 instantiations of VirtualChar

Microsoft.CodeAnalysis.Workspaces (2)

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

54=> new(rune, surrogateChar: default, span); 66return new VirtualChar(rune: Rune.ReplacementChar, surrogateChar, span);

218 references to VirtualChar

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

EmbeddedLanguages\RegularExpressions\CSharpRegexParserTests.cs (1)

379Assert.True(RegexLexer.IsEscapeCategoryChar(VirtualChar.Create(new Rune(ch), new TextSpan(0, 1))));

Microsoft.CodeAnalysis.CSharp.Features (23)

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

189foreach (var ch in characters) 220var ch = characters[i]; 270var result = ImmutableSegmentedList.CreateBuilder<VirtualChar>(); 293private static void AddRange(ImmutableSegmentedList<VirtualChar>.Builder result, VirtualCharSequence sequence) 295foreach (var c in sequence)

ConvertToRawString\ConvertToRawStringHelpers.cs (6)

32public static bool IsCSharpNewLine(VirtualChar ch) 35public static bool IsCSharpWhitespace(VirtualChar ch) 48public static bool AllEscapesAre(VirtualCharSequence sequence, Func<VirtualChar, bool> predicate) 52foreach (var ch in sequence) 89foreach (var ch in characters) 104private static bool CanConvert(VirtualChar ch)

EmbeddedLanguages\CSharpTestEmbeddedLanguageClassifier.cs (7)

27private static TextSpan FromBounds(VirtualChar vc1, VirtualChar vc2) 139var builder = ImmutableSegmentedList.CreateBuilder<VirtualChar>(); 146var vc1 = virtualChars[i]; 147var vc2 = i + 1 < n ? virtualChars[i + 1] : default; 180var vc3 = i + 2 < n ? virtualChars[i + 2] : default; 215var colonChar = virtualChars[seekPoint];

Microsoft.CodeAnalysis.CSharp.Workspaces (10)

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

25private static readonly ObjectPool<ImmutableSegmentedList<VirtualChar>.Builder> s_pooledBuilders = new(() => ImmutableSegmentedList.CreateBuilder<VirtualChar>()); 134var result = ImmutableSegmentedList.CreateBuilder<VirtualChar>(); 202var result = ImmutableSegmentedList.CreateBuilder<VirtualChar>(); 327private static void ConvertCharactersToRunes(ArrayBuilder<(char ch, TextSpan span)> charResults, ImmutableSegmentedList<VirtualChar>.Builder runeResults) 336runeResults.Add(VirtualChar.Create(rune, span)); 347runeResults.Add(VirtualChar.Create(rune, TextSpan.FromBounds(span.Start, nextSpan.End))); 355runeResults.Add(VirtualChar.Create(ch, span)); 370public 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 (11)

EmbeddedLanguages\AspNetCoreVirtualChar.cs (10)

13internal readonly VirtualChar VirtualChar; 15internal AspNetCoreVirtualChar(VirtualChar virtualChar) 30/// <inheritdoc cref="VirtualChar.SurrogateChar"/> 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)

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

Microsoft.CodeAnalysis.Features (84)

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)

91foreach (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 (11)

40public static VirtualChar MapEscapeChar(VirtualChar ch) 43'a' => VirtualChar.Create(new Rune('\u0007'), ch.Span), // bell 44'b' => VirtualChar.Create(new Rune('\b'), ch.Span), // backspace 45'e' => VirtualChar.Create(new Rune('\u001B'), ch.Span), // escape 46'f' => VirtualChar.Create(new Rune('\f'), ch.Span), // form feed 47'n' => VirtualChar.Create(new Rune('\n'), ch.Span), // new line 48'r' => VirtualChar.Create(new Rune('\r'), ch.Span), // carriage return 49't' => VirtualChar.Create(new Rune('\t'), ch.Span), // tab 50'v' => VirtualChar.Create(new Rune('\u000B'), ch.Span), // vertical tab 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 (8)

25/// Produces a <see cref="RegexTree"/> from a sequence of <see cref="VirtualChar"/> characters. 1182foreach (var ch in optionsToken.VirtualChars) 1206private static RegexOptions OptionFromCode(VirtualChar ch) 1404foreach (var vc in hexText.VirtualChars) 1414private static int HexValue(VirtualChar ch) 1479var nextChar = _currentToken.VirtualChars[0]; 1623var ch = _currentToken.VirtualChars[0]; 1812var ch = _currentToken.VirtualChars[0];

EmbeddedLanguages\StackFrame\StackFrameLexer.cs (8)

49foreach (var c in text) 60public readonly VirtualChar CurrentChar => Position < Text.Length ? Text[Position] : default; 91var ch = CurrentChar; 130var ch = Text[Position]; 385public static bool IsBlank(VirtualChar ch) 401private static bool IsAsciiAlphaCharacter(VirtualChar ch) 506private static StackFrameKind GetKind(VirtualChar ch) 537private 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 (82)

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

16public abstract bool TryGetEscapeCharacter(VirtualChar ch, out char escapedChar); 84var currentVC = result[0]; 97var nextVC = result[i]; 106var nextVC = result[i]; 112var lastVC = result.Last(); 160var result = ImmutableSegmentedList.CreateBuilder<VirtualChar>(); 167result.Add(VirtualChar.Create(new Rune('"'), new TextSpan(offset + index, 2))); 176result.Add(VirtualChar.Create(new Rune(tokenText[index]), span)); 191protected static int ConvertTextAtIndexToRune(string tokenText, int index, ImmutableSegmentedList<VirtualChar>.Builder result, int offset) 194protected static int ConvertTextAtIndexToRune(SourceText tokenText, int index, ImmutableSegmentedList<VirtualChar>.Builder result, int offset) 198T tokenText, int index, TTextInfo info, ImmutableSegmentedList<VirtualChar>.Builder result, int offset) 206result.Add(VirtualChar.Create(rune, new TextSpan(offset + index, 1))); 213result.Add(VirtualChar.Create(rune, new TextSpan(offset + index, 2))); 220result.Add(VirtualChar.Create(ch, new TextSpan(offset + index, 1))); 231ImmutableSegmentedList<VirtualChar>.Builder result)

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

29/// Takes in a string token and return the <see cref="VirtualChar"/>s corresponding to each 50/// VirtualChar in the result array with a matching <see cref="VirtualChar.Rune"/> property. 51/// Similarly, each VirtualChar's <see cref="VirtualChar.Span"/> will abut each other, and 70bool TryGetEscapeCharacter(VirtualChar ch, out char escapeChar);

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

12/// <see cref="VirtualChar"/> provides a uniform view of a language's string token characters regardless if they 16/// (<c>\</c> and <c>t</c>). <see cref="VirtualChar"/> will represent both, providing the raw <see cref="char"/> 26internal readonly record struct VirtualChar : IComparable<VirtualChar>, IComparable<char> 29/// The value of this <see cref="VirtualChar"/> as a <see cref="Rune"/> if such a representation is possible. 45/// cref="VirtualChar"/>. 50/// Creates a new <see cref="VirtualChar"/> from the provided <paramref name="rune"/>. This operation cannot 53public static VirtualChar Create(Rune rune, TextSpan span) 57/// Creates a new <see cref="VirtualChar"/> from an unpaired high or low surrogate character. This will throw 61public static VirtualChar Create(char surrogateChar, TextSpan span) 106public static bool operator ==(VirtualChar ch1, char ch2) 109public static bool operator !=(VirtualChar ch1, char ch2) 140public int CompareTo(VirtualChar other) 143public static bool operator <(VirtualChar ch1, VirtualChar ch2) 146public static bool operator <=(VirtualChar ch1, VirtualChar ch2) 149public static bool operator >(VirtualChar ch1, VirtualChar ch2) 152public static bool operator >=(VirtualChar ch1, VirtualChar ch2) 158public static bool operator <(VirtualChar ch1, char ch2) 161public static bool operator <=(VirtualChar ch1, char ch2) 164public static bool operator >(VirtualChar ch1, char ch2) 167public static bool operator >=(VirtualChar ch1, char ch2)

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

17/// Abstraction over a contiguous chunk of <see cref="VirtualChar"/>s. This 18/// is used so we can expose <see cref="VirtualChar"/>s over an <see cref="ImmutableArray{VirtualChar}"/> 29public abstract VirtualChar this[int index] { get; } 30public abstract VirtualChar? Find(int position); 38private sealed class ImmutableSegmentedListChunk(ImmutableSegmentedList<VirtualChar> array) : Chunk 41public override VirtualChar this[int index] => array[index]; 43public override VirtualChar? Find(int position) 86public override VirtualChar? Find(int position) 95public override VirtualChar this[int index] 112? VirtualChar.Create(ch, span) 113: VirtualChar.Create(new Rune(ch), span);

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

30public static readonly VirtualCharSequence Empty = Create(ImmutableSegmentedList<VirtualChar>.Empty); 32public static VirtualCharSequence Create(ImmutableSegmentedList<VirtualChar> virtualChars) 72/// Gets the <see cref="VirtualChar"/> at the specified index. 74public VirtualChar this[int index] => _leafCharacters[_span.Start + index]; 92public VirtualChar First() => this[0]; 93public VirtualChar Last() => this[^1]; 99public VirtualChar? Find(int position) 102public bool Contains(VirtualChar @char) 105public int IndexOf(VirtualChar @char) 108foreach (var ch in this) 119public VirtualChar? FirstOrNull(Func<VirtualChar, bool> predicate) 121foreach (var ch in this) 130public VirtualChar? LastOrNull(Func<VirtualChar, bool> predicate) 134var ch = this[i]; 142public bool Any(Func<VirtualChar, bool> predicate) 144foreach (var ch in this) 153public bool All(Func<VirtualChar, bool> predicate) 155foreach (var ch in this) 167public VirtualCharSequence SkipWhile(Func<VirtualChar, bool> predicate) 170foreach (var ch in this) 187foreach (var ch in this)

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

12public struct Enumerator(VirtualCharSequence virtualCharSequence) : IEnumerator<VirtualChar> 17public readonly VirtualChar Current => virtualCharSequence[_position];