private static BraceMatchingResult?FindBraceMatchingResult(JsonNode node, VirtualChar ch)
{
var fullSpan = node.GetFullSpan();
if (fullSpan == null)
{
return(null);
}
if (!fullSpan.Value.Contains(ch.Span.Start))
{
return(null);
}
switch (node)
{
case JsonArrayNode array when Matches(array.OpenBracketToken, array.CloseBracketToken, ch):
return(Create(array.OpenBracketToken, array.CloseBracketToken));
case JsonObjectNode obj when Matches(obj.OpenBraceToken, obj.CloseBraceToken, ch):
return(Create(obj.OpenBraceToken, obj.CloseBraceToken));
case JsonConstructorNode cons when Matches(cons.OpenParenToken, cons.CloseParenToken, ch):
return(Create(cons.OpenParenToken, cons.CloseParenToken));
}
foreach (var child in node)
{
if (child.IsNode)
{
var result = FindBraceMatchingResult(child.Node, ch);
if (result != null)
{
return(result);
}
}
}
return(null);
}
private static TNode FindNode <TNode>(RegexNode node, VirtualChar ch, Func <TNode, VirtualChar, bool> predicate)
where TNode : RegexNode
{
if (node is TNode nodeMatch && predicate(nodeMatch, ch))
{
return(nodeMatch);
}
foreach (var child in node)
{
if (child.IsNode)
{
var result = FindNode(child.Node, ch, predicate);
if (result != null)
{
return(result);
}
}
}
return(null);
}
public bool Contains(VirtualChar virtualChar)
{
foreach (var child in this)
{
if (child.IsNode)
{
if (child.Node.Contains(virtualChar))
{
return(true);
}
}
else
{
if (child.Token.VirtualChars.Contains(virtualChar))
{
return(true);
}
}
}
return(false);
}
private (RegexNode parent, RegexToken Token)? FindToken(
RegexNode parent, VirtualChar ch)
{
foreach (var child in parent)
{
if (child.IsNode)
{
var result = FindToken(child.Node, ch);
if (result != null)
{
return(result);
}
}
else
{
if (child.Token.VirtualChars.Contains(ch))
{
return(parent, child.Token);
}
}
}
return(null);
}
private static RegexBaseCharacterClassNode FindCharacterClassNode(RegexNode node, VirtualChar ch)
=> FindNode <RegexBaseCharacterClassNode>(node, ch, (grouping, c) =>
grouping.OpenBracketToken.VirtualChars.Contains(c) || grouping.CloseBracketToken.VirtualChars.Contains(c));
private static RegexGroupingNode FindGroupingNode(RegexNode node, VirtualChar ch)
=> FindNode <RegexGroupingNode>(node, ch, (grouping, c) =>
grouping.OpenParenToken.VirtualChars.Contains(c) || grouping.CloseParenToken.VirtualChars.Contains(c));
private static EmbeddedBraceMatchingResult?FindCharacterClassBraces(RegexTree tree, VirtualChar ch)
{
var node = FindCharacterClassNode(tree.Root, ch);
return(node == null ? null : CreateResult(node.OpenBracketToken, node.CloseBracketToken));
}
private static EmbeddedBraceMatchingResult?FindGroupingBraces(RegexTree tree, VirtualChar ch)
{
var node = FindGroupingNode(tree.Root, ch);
return(node == null ? null : CreateResult(node.OpenParenToken, node.CloseParenToken));
}
internal AspNetCoreVirtualChar(VirtualChar virtualChar)
{
_virtualChar = virtualChar;
}
private static bool Matches(JsonToken openToken, JsonToken closeToken, VirtualChar ch) => openToken.VirtualChars.Contains(ch) || closeToken.VirtualChars.Contains(ch);
private static string ConvertRuneToString(VirtualChar c)
=> PrintAsUnicodeEscape(c)
? c <= char.MaxValue ? $"'\\u{c.Value:X4}'" : $"'\\U{c.Value:X8}'"
: $"'{(char)c.Value}'";
private static string ConvertToString(VirtualChar vc)
=> $"[{ConvertRuneToString(vc)},[{vc.Span.Start - _statementPrefix.Length},{vc.Span.End - _statementPrefix.Length}]]";
public static TextSpan GetSpan(VirtualChar firstChar, VirtualChar lastChar) => TextSpan.FromBounds(firstChar.Span.Start, lastChar.Span.End);
/// <summary>
/// Maps an escaped character to the actual character it was escaping. For something like
/// 'a' this will map to actual '\a' char (the bell character). However, for something like
/// '(' this will just map to '(' as that's all that \( does in a regex.
/// </summary>
public static VirtualChar MapEscapeChar(VirtualChar ch)
=> ch.Value switch
{
'a' => VirtualChar.Create(new Rune('\u0007'), ch.Span), // bell
private static bool IsLegalPropertyNameChar(VirtualChar ch) => ch.IsLetterOrDigit || ch == '_' || ch == '$';
private static RegexTrivia?TryGetTrivia(ImmutableArray <RegexTrivia> triviaList, VirtualChar ch)
{
foreach (var trivia in triviaList)
{
if (trivia.VirtualChars.Contains(ch))
{
return(trivia);
}
}
return(null);
}
private static BraceMatchingResult?FindBraceHighlights(JsonTree tree, VirtualChar ch) => FindBraceMatchingResult(tree.Root, ch);
public static bool TryGetEscapeCharacter(this VirtualChar ch, out char escapedChar) => TryGetEscapeCharacter(ch.Value, out escapedChar);
