// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
#nullable disable
 
using System;
using System.Collections.Immutable;
using System.Diagnostics;
using Microsoft.CodeAnalysis.EmbeddedLanguages.Common;
 
namespace Microsoft.CodeAnalysis.EmbeddedLanguages.RegularExpressions;
 
using RegexNodeOrToken = EmbeddedSyntaxNodeOrToken<RegexKind, RegexNode>;
using RegexToken = EmbeddedSyntaxToken<RegexKind>;
using RegexAlternatingSequenceList = EmbeddedSeparatedSyntaxNodeList<RegexKind, RegexNode, RegexSequenceNode>;
 
internal sealed class RegexCompilationUnit : RegexNode
{
    public RegexCompilationUnit(RegexExpressionNode expression, RegexToken endOfFileToken)
        : base(RegexKind.CompilationUnit)
    {
        Debug.Assert(expression != null);
        Debug.Assert(endOfFileToken.Kind == RegexKind.EndOfFile);
        Expression = expression;
        EndOfFileToken = endOfFileToken;
    }
 
    public RegexExpressionNode Expression { get; }
    public RegexToken EndOfFileToken { get; }
 
    internal override int ChildCount => 2;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => Expression,
            1 => EndOfFileToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// Represents a possibly-empty sequence of regex expressions.  For example, the regex ""
/// will produce an empty RegexSequence nodes, and "a|" will produce an alternation with an
/// empty sequence on the right side.  Having a node represent the empty sequence is actually
/// appropriate as these are legal regexes and the empty sequence represents 'a pattern
/// that will match any position'.  Not having a node for this would actually end up 
/// complicating things in terms of dealing with nulls in the tree.
/// 
/// This does not deviate from Roslyn principles.  While nodes for empty text are rare, they
/// are allowed (for example, OmittedTypeArgument in C#).
/// </summary>
internal sealed class RegexSequenceNode(ImmutableArray<RegexExpressionNode> children) : RegexExpressionNode(RegexKind.Sequence)
{
    public ImmutableArray<RegexExpressionNode> Children { get; } = children;
 
    internal override int ChildCount => Children.Length;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => Children[index];
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// Represents a chunk of text (usually just a single char) from the original pattern.
/// </summary>
internal sealed class RegexTextNode : RegexPrimaryExpressionNode
{
    public RegexTextNode(RegexToken textToken)
        : base(RegexKind.Text)
    {
        Debug.Assert(textToken.Kind == RegexKind.TextToken);
        TextToken = textToken;
    }
 
    public RegexToken TextToken { get; }
 
    internal override int ChildCount => 1;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => TextToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// Base type for [...] and [^...] character classes.
/// </summary>
internal abstract class RegexBaseCharacterClassNode : RegexPrimaryExpressionNode
{
    protected RegexBaseCharacterClassNode(
        RegexKind kind, RegexToken openBracketToken, RegexSequenceNode components, RegexToken closeBracketToken)
        : base(kind)
    {
        Debug.Assert(openBracketToken.Kind == RegexKind.OpenBracketToken);
        Debug.Assert(components != null);
        Debug.Assert(closeBracketToken.Kind == RegexKind.CloseBracketToken);
        OpenBracketToken = openBracketToken;
        Components = components;
        CloseBracketToken = closeBracketToken;
    }
 
    public RegexToken OpenBracketToken { get; }
    public RegexSequenceNode Components { get; }
    public RegexToken CloseBracketToken { get; }
}
 
/// <summary>
/// [...] node.
/// </summary>
internal sealed class RegexCharacterClassNode(
    RegexToken openBracketToken, RegexSequenceNode components, RegexToken closeBracketToken) : RegexBaseCharacterClassNode(RegexKind.CharacterClass, openBracketToken, components, closeBracketToken)
{
    internal override int ChildCount => 3;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenBracketToken,
            1 => Components,
            2 => CloseBracketToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// [^...] node
/// </summary>
internal sealed class RegexNegatedCharacterClassNode : RegexBaseCharacterClassNode
{
    public RegexNegatedCharacterClassNode(
        RegexToken openBracketToken, RegexToken caretToken, RegexSequenceNode components, RegexToken closeBracketToken)
        : base(RegexKind.NegatedCharacterClass, openBracketToken, components, closeBracketToken)
    {
        Debug.Assert(caretToken.Kind == RegexKind.CaretToken);
        CaretToken = caretToken;
    }
 
    public RegexToken CaretToken { get; }
 
    internal override int ChildCount => 4;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenBracketToken,
            1 => CaretToken,
            2 => Components,
            3 => CloseBracketToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```a-z``` node in a character class.
/// </summary>
internal sealed class RegexCharacterClassRangeNode : RegexPrimaryExpressionNode
{
    public RegexCharacterClassRangeNode(
        RegexExpressionNode left, RegexToken minusToken, RegexExpressionNode right)
        : base(RegexKind.CharacterClassRange)
    {
        Debug.Assert(left != null);
        Debug.Assert(minusToken.Kind == RegexKind.MinusToken);
        Debug.Assert(right != null);
        Left = left;
        MinusToken = minusToken;
        Right = right;
    }
 
    public RegexExpressionNode Left { get; }
    public RegexToken MinusToken { get; }
    public RegexExpressionNode Right { get; }
 
    internal override int ChildCount => 3;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => Left,
            1 => MinusToken,
            2 => Right,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```-[f-m]``` in a pattern like ```[a-z-[f-m]]```.  A subtraction must come last in a 
/// character class, and removes some range of chars from the character class built up
/// so far.
/// </summary>
internal sealed class RegexCharacterClassSubtractionNode : RegexPrimaryExpressionNode
{
    public RegexCharacterClassSubtractionNode(
        RegexToken minusToken, RegexBaseCharacterClassNode characterClass)
        : base(RegexKind.CharacterClassSubtraction)
    {
        Debug.Assert(minusToken.Kind == RegexKind.MinusToken);
        Debug.Assert(characterClass != null);
        MinusToken = minusToken;
        CharacterClass = characterClass;
    }
 
    public RegexToken MinusToken { get; }
    public RegexBaseCharacterClassNode CharacterClass { get; }
 
    internal override int ChildCount => 2;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => MinusToken,
            1 => CharacterClass,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// Represents a ```[:...:]``` node in a character class.  Note: the .NET regex parser
/// simply treats this as the character ```[``` and ignores the rest of the ```:...:]```.
/// They latter part has no impact on the actual match engine that is produced.
/// </summary>
internal sealed class RegexPosixPropertyNode : RegexPrimaryExpressionNode
{
    public RegexPosixPropertyNode(RegexToken textToken)
        : base(RegexKind.PosixProperty)
    {
        Debug.Assert(textToken.Kind == RegexKind.TextToken);
        TextToken = textToken;
    }
 
    public RegexToken TextToken { get; }
 
    internal override int ChildCount => 1;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => TextToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// Root of all expression nodes.
/// </summary>
internal abstract class RegexExpressionNode : RegexNode
{
    protected RegexExpressionNode(RegexKind kind)
        : base(kind)
    {
    }
}
 
/// <summary>
/// Root of all the primary nodes (similar to unary nodes in C#).
/// </summary>
internal abstract class RegexPrimaryExpressionNode : RegexExpressionNode
{
    protected RegexPrimaryExpressionNode(RegexKind kind)
        : base(kind)
    {
    }
}
 
/// <summary>
/// A ```.``` expression.
/// </summary>
internal sealed class RegexWildcardNode : RegexPrimaryExpressionNode
{
    public RegexWildcardNode(RegexToken dotToken)
        : base(RegexKind.Wildcard)
    {
        Debug.Assert(dotToken.Kind == RegexKind.DotToken);
        DotToken = dotToken;
    }
 
    public RegexToken DotToken { get; }
 
    internal override int ChildCount => 1;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => DotToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// Root of all quantifier nodes: ```?```, ```*``` etc.
/// </summary>
internal abstract class RegexQuantifierNode : RegexExpressionNode
{
    protected RegexQuantifierNode(RegexKind kind)
        : base(kind)
    {
    }
}
 
/// <summary>
/// ```expr*```
/// </summary>
internal sealed class RegexZeroOrMoreQuantifierNode : RegexQuantifierNode
{
    public RegexZeroOrMoreQuantifierNode(
        RegexExpressionNode expression, RegexToken asteriskToken)
        : base(RegexKind.ZeroOrMoreQuantifier)
    {
        Debug.Assert(expression != null);
        Debug.Assert(asteriskToken.Kind == RegexKind.AsteriskToken);
        Expression = expression;
        AsteriskToken = asteriskToken;
    }
 
    public RegexExpressionNode Expression { get; }
    public RegexToken AsteriskToken { get; }
 
    internal override int ChildCount => 2;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => this.Expression,
            1 => this.AsteriskToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```expr+```
/// </summary>
internal sealed class RegexOneOrMoreQuantifierNode : RegexQuantifierNode
{
    public RegexOneOrMoreQuantifierNode(
        RegexExpressionNode expression, RegexToken plusToken)
        : base(RegexKind.OneOrMoreQuantifier)
    {
        Debug.Assert(expression != null);
        Debug.Assert(plusToken.Kind == RegexKind.PlusToken);
        Expression = expression;
        PlusToken = plusToken;
    }
 
    public RegexExpressionNode Expression { get; }
    public RegexToken PlusToken { get; }
 
    internal override int ChildCount => 2;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => this.Expression,
            1 => this.PlusToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```expr?```
/// </summary>
internal sealed class RegexZeroOrOneQuantifierNode : RegexQuantifierNode
{
    public RegexZeroOrOneQuantifierNode(
        RegexExpressionNode expression, RegexToken questionToken)
        : base(RegexKind.ZeroOrOneQuantifier)
    {
        Debug.Assert(expression != null);
        Debug.Assert(questionToken.Kind == RegexKind.QuestionToken);
        Expression = expression;
        QuestionToken = questionToken;
    }
 
    public RegexExpressionNode Expression { get; }
    public RegexToken QuestionToken { get; }
 
    internal override int ChildCount => 2;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => this.Expression,
            1 => this.QuestionToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// Quantifiers can be optionally followed by a ? to make them lazy.  i.e. ```a*?``` or ```a+?```.
/// You can even have ```a??```  (zero or one 'a', lazy).  However, only one lazy modifier is allowed
/// ```a*??``` or ```a???``` is not allowed.
/// </summary>
internal sealed class RegexLazyQuantifierNode : RegexExpressionNode
{
    public RegexLazyQuantifierNode(
        RegexQuantifierNode quantifier, RegexToken questionToken)
        : base(RegexKind.LazyQuantifier)
    {
        Debug.Assert(quantifier != null);
        Debug.Assert(quantifier.Kind != RegexKind.LazyQuantifier);
        Debug.Assert(questionToken.Kind == RegexKind.QuestionToken);
        Quantifier = quantifier;
        QuestionToken = questionToken;
    }
 
    public RegexQuantifierNode Quantifier { get; }
    public RegexToken QuestionToken { get; }
 
    internal override int ChildCount => 2;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => this.Quantifier,
            1 => this.QuestionToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// Base type of all regex numeric quantifier nodes.  i.e.  
/// ```a{5}```,  ```a{5,}``` and ```a{5,10}```
/// </summary>
internal abstract class RegexNumericQuantifierNode : RegexQuantifierNode
{
    protected RegexNumericQuantifierNode(
        RegexKind kind, RegexPrimaryExpressionNode expression, RegexToken openBraceToken, RegexToken firstNumberToken, RegexToken closeBraceToken)
        : base(kind)
    {
        Debug.Assert(expression != null);
        Debug.Assert(openBraceToken.Kind == RegexKind.OpenBraceToken);
        Debug.Assert(firstNumberToken.Kind == RegexKind.NumberToken);
        Debug.Assert(closeBraceToken.Kind == RegexKind.CloseBraceToken);
        Expression = expression;
        OpenBraceToken = openBraceToken;
        FirstNumberToken = firstNumberToken;
        CloseBraceToken = closeBraceToken;
    }
 
    public RegexExpressionNode Expression { get; }
    public RegexToken OpenBraceToken { get; }
    public RegexToken FirstNumberToken { get; }
    public RegexToken CloseBraceToken { get; }
}
 
/// <summary>
/// ```a{5}```
/// </summary>
internal sealed class RegexExactNumericQuantifierNode(
    RegexPrimaryExpressionNode expression, RegexToken openBraceToken, RegexToken numberToken, RegexToken closeBraceToken) : RegexNumericQuantifierNode(RegexKind.ExactNumericQuantifier, expression, openBraceToken, numberToken, closeBraceToken)
{
    internal override int ChildCount => 4;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => Expression,
            1 => OpenBraceToken,
            2 => FirstNumberToken,
            3 => CloseBraceToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```a{5,}```
/// </summary>
internal sealed class RegexOpenNumericRangeQuantifierNode : RegexNumericQuantifierNode
{
    public RegexOpenNumericRangeQuantifierNode(
        RegexPrimaryExpressionNode expression,
        RegexToken openBraceToken, RegexToken firstNumberToken,
        RegexToken commaToken, RegexToken closeBraceToken)
        : base(RegexKind.OpenRangeNumericQuantifier, expression, openBraceToken, firstNumberToken, closeBraceToken)
    {
        Debug.Assert(commaToken.Kind == RegexKind.CommaToken);
        CommaToken = commaToken;
    }
 
    public RegexToken CommaToken { get; }
 
    internal override int ChildCount => 5;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => Expression,
            1 => OpenBraceToken,
            2 => FirstNumberToken,
            3 => CommaToken,
            4 => CloseBraceToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```a{5,10}```
/// </summary>
internal sealed class RegexClosedNumericRangeQuantifierNode : RegexNumericQuantifierNode
{
    public RegexClosedNumericRangeQuantifierNode(
        RegexPrimaryExpressionNode expression,
        RegexToken openBraceToken, RegexToken firstNumberToken,
        RegexToken commaToken, RegexToken secondNumberToken, RegexToken closeBraceToken)
        : base(RegexKind.ClosedRangeNumericQuantifier, expression, openBraceToken, firstNumberToken, closeBraceToken)
    {
        Debug.Assert(commaToken.Kind == RegexKind.CommaToken);
        Debug.Assert(secondNumberToken.Kind == RegexKind.NumberToken);
        CommaToken = commaToken;
        SecondNumberToken = secondNumberToken;
    }
 
    public RegexToken CommaToken { get; }
    public RegexToken SecondNumberToken { get; }
 
    internal override int ChildCount => 6;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => Expression,
            1 => OpenBraceToken,
            2 => FirstNumberToken,
            3 => CommaToken,
            4 => SecondNumberToken,
            5 => CloseBraceToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```$``` or ```^```.
/// </summary>
internal sealed class RegexAnchorNode : RegexPrimaryExpressionNode
{
    public RegexAnchorNode(RegexKind kind, RegexToken anchorToken)
        : base(kind)
    {
        Debug.Assert(anchorToken.Kind is RegexKind.DollarToken or RegexKind.CaretToken);
        AnchorToken = anchorToken;
    }
 
    public RegexToken AnchorToken { get; }
 
    internal override int ChildCount => 1;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => AnchorToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```expr1|expr2``` node.
/// </summary>
internal sealed class RegexAlternationNode : RegexExpressionNode
{
    public RegexAlternationNode(RegexAlternatingSequenceList sequenceList)
        : base(RegexKind.Alternation)
    {
        Debug.Assert(sequenceList.NodesAndTokens.Length > 0);
        for (var i = 1; i < sequenceList.NodesAndTokens.Length; i += 2)
            Debug.Assert(sequenceList.NodesAndTokens[i].Kind == RegexKind.BarToken);
 
        SequenceList = sequenceList;
    }
 
    public RegexAlternatingSequenceList SequenceList { get; }
 
    internal override int ChildCount => SequenceList.NodesAndTokens.Length;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => SequenceList.NodesAndTokens[index];
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// Base type of all non-trivia ```(...)``` nodes
/// </summary>
internal abstract class RegexGroupingNode : RegexPrimaryExpressionNode
{
    protected RegexGroupingNode(RegexKind kind, RegexToken openParenToken, RegexToken closeParenToken)
        : base(kind)
    {
        Debug.Assert(openParenToken.Kind == RegexKind.OpenParenToken);
        Debug.Assert(closeParenToken.Kind == RegexKind.CloseParenToken);
        OpenParenToken = openParenToken;
        CloseParenToken = closeParenToken;
    }
 
    public RegexToken OpenParenToken { get; }
    public RegexToken CloseParenToken { get; }
}
 
/// <summary>
/// The ```(...)``` node you get when the group does not start with ```(?```
/// </summary>
internal sealed class RegexSimpleGroupingNode : RegexGroupingNode
{
    public RegexSimpleGroupingNode(RegexToken openParenToken, RegexExpressionNode expression, RegexToken closeParenToken)
        : base(RegexKind.SimpleGrouping, openParenToken, closeParenToken)
    {
        Debug.Assert(expression != null);
        Expression = expression;
    }
 
    public RegexExpressionNode Expression { get; }
 
    internal override int ChildCount => 3;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenParenToken,
            1 => Expression,
            2 => CloseParenToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// Base type of all ```(?...)``` groupings.
/// </summary>
internal abstract class RegexQuestionGroupingNode : RegexGroupingNode
{
    protected RegexQuestionGroupingNode(RegexKind kind, RegexToken openParenToken, RegexToken questionToken, RegexToken closeParenToken)
        : base(kind, openParenToken, closeParenToken)
    {
        Debug.Assert(questionToken.Kind == RegexKind.QuestionToken);
        QuestionToken = questionToken;
    }
 
    public RegexToken QuestionToken { get; }
}
 
/// <summary>
/// Base type of ```(?inmsx)``` or ```(?inmsx:...)``` nodes.
/// </summary>
internal abstract class RegexOptionsGroupingNode : RegexQuestionGroupingNode
{
    protected RegexOptionsGroupingNode(RegexKind kind, RegexToken openParenToken, RegexToken questionToken, RegexToken optionsToken, RegexToken closeParenToken)
        : base(kind, openParenToken, questionToken, closeParenToken)
    {
        OptionsToken = optionsToken;
    }
 
    public RegexToken OptionsToken { get; }
}
 
/// <summary>
/// ```(?inmsx)``` node.  Changes options in a sequence for all subsequence nodes.
/// </summary>
internal sealed class RegexSimpleOptionsGroupingNode(
    RegexToken openParenToken, RegexToken questionToken, RegexToken optionsToken, RegexToken closeParenToken) : RegexOptionsGroupingNode(RegexKind.SimpleOptionsGrouping, openParenToken, questionToken, optionsToken, closeParenToken)
{
    internal override int ChildCount => 4;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenParenToken,
            1 => QuestionToken,
            2 => OptionsToken,
            3 => CloseParenToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```(?inmsx:expr)``` node.  Changes options for the parsing of 'expr'.
/// </summary>
internal sealed class RegexNestedOptionsGroupingNode : RegexOptionsGroupingNode
{
    public RegexNestedOptionsGroupingNode(
        RegexToken openParenToken, RegexToken questionToken, RegexToken optionsToken,
        RegexToken colonToken, RegexExpressionNode expression, RegexToken closeParenToken)
        : base(RegexKind.NestedOptionsGrouping, openParenToken, questionToken, optionsToken, closeParenToken)
    {
        Debug.Assert(colonToken.Kind == RegexKind.ColonToken);
        Debug.Assert(expression != null);
        ColonToken = colonToken;
        Expression = expression;
    }
 
    public RegexToken ColonToken { get; }
    public RegexExpressionNode Expression { get; }
 
    internal override int ChildCount => 6;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenParenToken,
            1 => QuestionToken,
            2 => OptionsToken,
            3 => ColonToken,
            4 => Expression,
            5 => CloseParenToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```(?:expr)``` node.
/// </summary>
internal sealed class RegexNonCapturingGroupingNode : RegexQuestionGroupingNode
{
    public RegexNonCapturingGroupingNode(
        RegexToken openParenToken, RegexToken questionToken, RegexToken colonToken,
        RegexExpressionNode expression, RegexToken closeParenToken)
        : base(RegexKind.NonCapturingGrouping, openParenToken, questionToken, closeParenToken)
    {
        Debug.Assert(colonToken.Kind == RegexKind.ColonToken);
        Debug.Assert(expression != null);
        ColonToken = colonToken;
        Expression = expression;
    }
 
    public RegexToken ColonToken { get; }
    public RegexExpressionNode Expression { get; }
 
    internal override int ChildCount => 5;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenParenToken,
            1 => QuestionToken,
            2 => ColonToken,
            3 => Expression,
            4 => CloseParenToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```(?=expr)``` node.
/// </summary>
internal sealed class RegexPositiveLookaheadGroupingNode : RegexQuestionGroupingNode
{
    public RegexPositiveLookaheadGroupingNode(
        RegexToken openParenToken, RegexToken questionToken, RegexToken equalsToken,
        RegexExpressionNode expression, RegexToken closeParenToken)
        : base(RegexKind.PositiveLookaheadGrouping, openParenToken, questionToken, closeParenToken)
    {
        Debug.Assert(equalsToken.Kind == RegexKind.EqualsToken);
        Debug.Assert(expression != null);
        EqualsToken = equalsToken;
        Expression = expression;
    }
 
    public RegexToken EqualsToken { get; }
    public RegexExpressionNode Expression { get; }
 
    internal override int ChildCount => 5;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenParenToken,
            1 => QuestionToken,
            2 => EqualsToken,
            3 => Expression,
            4 => CloseParenToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```(?!expr)``` node.
/// </summary>
internal sealed class RegexNegativeLookaheadGroupingNode : RegexQuestionGroupingNode
{
    public RegexNegativeLookaheadGroupingNode(
        RegexToken openParenToken, RegexToken questionToken, RegexToken exclamationToken,
        RegexExpressionNode expression, RegexToken closeParenToken)
        : base(RegexKind.NegativeLookaheadGrouping, openParenToken, questionToken, closeParenToken)
    {
        Debug.Assert(exclamationToken.Kind == RegexKind.ExclamationToken);
        Debug.Assert(expression != null);
        ExclamationToken = exclamationToken;
        Expression = expression;
    }
 
    public RegexToken ExclamationToken { get; }
    public RegexExpressionNode Expression { get; }
 
    internal override int ChildCount => 5;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenParenToken,
            1 => QuestionToken,
            2 => ExclamationToken,
            3 => Expression,
            4 => CloseParenToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
internal abstract class RegexLookbehindGroupingNode : RegexQuestionGroupingNode
{
    protected RegexLookbehindGroupingNode(
        RegexKind kind, RegexToken openParenToken, RegexToken questionToken,
        RegexToken lessThanToken, RegexToken closeParenToken)
        : base(kind, openParenToken, questionToken, closeParenToken)
    {
        Debug.Assert(lessThanToken.Kind == RegexKind.LessThanToken);
        LessThanToken = lessThanToken;
    }
 
    public RegexToken LessThanToken { get; }
}
 
/// <summary>
/// ```(?&lt;=expr)``` node.
/// </summary>
internal sealed class RegexPositiveLookbehindGroupingNode : RegexLookbehindGroupingNode
{
    public RegexPositiveLookbehindGroupingNode(
        RegexToken openParenToken, RegexToken questionToken, RegexToken lessThanToken,
        RegexToken equalsToken, RegexExpressionNode expression, RegexToken closeParenToken)
        : base(RegexKind.PositiveLookbehindGrouping, openParenToken, questionToken, lessThanToken, closeParenToken)
    {
        Debug.Assert(equalsToken.Kind == RegexKind.EqualsToken);
        Debug.Assert(expression != null);
        EqualsToken = equalsToken;
        Expression = expression;
    }
 
    public RegexToken EqualsToken { get; }
    public RegexExpressionNode Expression { get; }
 
    internal override int ChildCount => 6;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenParenToken,
            1 => QuestionToken,
            2 => LessThanToken,
            3 => EqualsToken,
            4 => Expression,
            5 => CloseParenToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```(?&lt;!expr)``` node.
/// </summary>
internal sealed class RegexNegativeLookbehindGroupingNode : RegexLookbehindGroupingNode
{
    public RegexNegativeLookbehindGroupingNode(
        RegexToken openParenToken, RegexToken questionToken, RegexToken lessThanToken,
        RegexToken exclamationToken, RegexExpressionNode expression, RegexToken closeParenToken)
        : base(RegexKind.NegativeLookbehindGrouping, openParenToken, questionToken, lessThanToken, closeParenToken)
    {
        Debug.Assert(exclamationToken.Kind == RegexKind.ExclamationToken);
        Debug.Assert(expression != null);
        ExclamationToken = exclamationToken;
        Expression = expression;
    }
 
    public RegexToken ExclamationToken { get; }
    public RegexExpressionNode Expression { get; }
 
    internal override int ChildCount => 6;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenParenToken,
            1 => QuestionToken,
            2 => LessThanToken,
            3 => ExclamationToken,
            4 => Expression,
            5 => CloseParenToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```(?&gt;expr)``` node.
/// </summary>
internal sealed class RegexAtomicGroupingNode : RegexQuestionGroupingNode
{
    public RegexAtomicGroupingNode(
        RegexToken openParenToken, RegexToken questionToken, RegexToken greaterThanToken,
        RegexExpressionNode expression, RegexToken closeParenToken)
        : base(RegexKind.AtomicGrouping, openParenToken, questionToken, closeParenToken)
    {
        Debug.Assert(greaterThanToken.Kind == RegexKind.GreaterThanToken);
        Debug.Assert(expression != null);
        GreaterThanToken = greaterThanToken;
        Expression = expression;
    }
 
    public RegexToken GreaterThanToken { get; }
    public RegexExpressionNode Expression { get; }
 
    internal override int ChildCount => 5;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenParenToken,
            1 => QuestionToken,
            2 => GreaterThanToken,
            3 => Expression,
            4 => CloseParenToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```(?'name'expr)``` or ```(?&lt;name&gt;expr)``` node.
/// </summary>
internal sealed class RegexCaptureGroupingNode : RegexQuestionGroupingNode
{
    public RegexCaptureGroupingNode(
        RegexToken openParenToken, RegexToken questionToken, RegexToken openToken,
        RegexToken captureToken, RegexToken closeToken,
        RegexExpressionNode expression, RegexToken closeParenToken)
        : base(RegexKind.CaptureGrouping, openParenToken, questionToken, closeParenToken)
    {
        Debug.Assert(expression != null);
        OpenToken = openToken;
        CaptureToken = captureToken;
        CloseToken = closeToken;
        Expression = expression;
    }
 
    public RegexToken OpenToken { get; }
    public RegexToken CaptureToken { get; }
    public RegexToken CloseToken { get; }
    public RegexExpressionNode Expression { get; }
 
    internal override int ChildCount => 7;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenParenToken,
            1 => QuestionToken,
            2 => OpenToken,
            3 => CaptureToken,
            4 => CloseToken,
            5 => Expression,
            6 => CloseParenToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```(?'name1-name2'expr)``` or ```(?&lt;name1-name2&gt;expr)``` node.
/// </summary>
internal sealed class RegexBalancingGroupingNode : RegexQuestionGroupingNode
{
    public RegexBalancingGroupingNode(
        RegexToken openParenToken, RegexToken questionToken, RegexToken openToken,
        RegexToken firstCaptureToken, RegexToken minusToken, RegexToken secondCaptureToken,
        RegexToken closeToken, RegexExpressionNode expression, RegexToken closeParenToken)
        : base(RegexKind.BalancingGrouping, openParenToken, questionToken, closeParenToken)
    {
        Debug.Assert(minusToken.Kind == RegexKind.MinusToken);
        Debug.Assert(expression != null);
        OpenToken = openToken;
        FirstCaptureToken = firstCaptureToken;
        MinusToken = minusToken;
        SecondCaptureToken = secondCaptureToken;
        CloseToken = closeToken;
        Expression = expression;
    }
 
    public RegexToken OpenToken { get; }
    public RegexToken FirstCaptureToken { get; }
    public RegexToken MinusToken { get; }
    public RegexToken SecondCaptureToken { get; }
    public RegexToken CloseToken { get; }
    public RegexExpressionNode Expression { get; }
 
    internal override int ChildCount => 9;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenParenToken,
            1 => QuestionToken,
            2 => OpenToken,
            3 => FirstCaptureToken,
            4 => MinusToken,
            5 => SecondCaptureToken,
            6 => CloseToken,
            7 => Expression,
            8 => CloseParenToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
internal abstract class RegexConditionalGroupingNode : RegexQuestionGroupingNode
{
    protected RegexConditionalGroupingNode(
        RegexKind kind, RegexToken openParenToken, RegexToken questionToken,
        RegexExpressionNode result, RegexToken closeParenToken)
        : base(kind, openParenToken, questionToken, closeParenToken)
    {
        Debug.Assert(result != null);
        Result = result;
    }
 
    public RegexExpressionNode Result { get; }
}
 
/// <summary>
/// ```(?(capture_name)result)```
/// </summary>
internal sealed class RegexConditionalCaptureGroupingNode : RegexConditionalGroupingNode
{
    public RegexConditionalCaptureGroupingNode(
        RegexToken openParenToken, RegexToken questionToken,
        RegexToken innerOpenParenToken, RegexToken captureToken, RegexToken innerCloseParenToken,
        RegexExpressionNode result, RegexToken closeParenToken)
        : base(RegexKind.ConditionalCaptureGrouping, openParenToken, questionToken, result, closeParenToken)
    {
        Debug.Assert(innerOpenParenToken.Kind == RegexKind.OpenParenToken);
        Debug.Assert(innerCloseParenToken.Kind == RegexKind.CloseParenToken);
        InnerOpenParenToken = innerOpenParenToken;
        CaptureToken = captureToken;
        InnerCloseParenToken = innerCloseParenToken;
    }
 
    public RegexToken InnerOpenParenToken { get; }
    public RegexToken CaptureToken { get; }
    public RegexToken InnerCloseParenToken { get; }
 
    internal override int ChildCount => 7;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenParenToken,
            1 => QuestionToken,
            2 => InnerOpenParenToken,
            3 => CaptureToken,
            4 => InnerCloseParenToken,
            5 => Result,
            6 => CloseParenToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```(?(group)result)```
/// </summary>
internal sealed class RegexConditionalExpressionGroupingNode : RegexConditionalGroupingNode
{
    public RegexConditionalExpressionGroupingNode(
        RegexToken openParenToken, RegexToken questionToken,
        RegexGroupingNode grouping,
        RegexExpressionNode result, RegexToken closeParenToken)
        : base(RegexKind.ConditionalExpressionGrouping, openParenToken, questionToken, result, closeParenToken)
    {
        Debug.Assert(grouping != null);
        Grouping = grouping;
    }
 
    internal override int ChildCount => 5;
 
    public RegexGroupingNode Grouping { get; }
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => OpenParenToken,
            1 => QuestionToken,
            2 => Grouping,
            3 => Result,
            4 => CloseParenToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// Base type of all regex primitives that start with \
/// </summary>
internal abstract class RegexEscapeNode : RegexPrimaryExpressionNode
{
    protected RegexEscapeNode(RegexKind kind, RegexToken backslashToken) : base(kind)
    {
        Debug.Assert(backslashToken.Kind == RegexKind.BackslashToken);
        BackslashToken = backslashToken;
    }
 
    public RegexToken BackslashToken { get; }
}
 
/// <summary>
/// Base type of all regex escapes that start with \ and some informative character (like \v \t \c etc.).
/// </summary>
internal abstract class RegexTypeEscapeNode : RegexEscapeNode
{
    protected RegexTypeEscapeNode(RegexKind kind, RegexToken backslashToken, RegexToken typeToken)
        : base(kind, backslashToken)
    {
        TypeToken = typeToken;
    }
 
    public RegexToken TypeToken { get; }
}
 
/// <summary>
/// A basic escape that just has \ and one additional character and needs no further information.
/// </summary>
internal sealed class RegexSimpleEscapeNode : RegexTypeEscapeNode
{
    public RegexSimpleEscapeNode(RegexToken backslashToken, RegexToken typeToken)
        : base(RegexKind.SimpleEscape, backslashToken, typeToken)
    {
        Debug.Assert(typeToken.Kind == RegexKind.TextToken);
    }
 
    internal override int ChildCount => 2;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => BackslashToken,
            1 => TypeToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// One of \b \B \A \G \z \Z
/// </summary>
internal sealed class RegexAnchorEscapeNode(RegexToken backslashToken, RegexToken typeToken) : RegexTypeEscapeNode(RegexKind.AnchorEscape, backslashToken, typeToken)
{
    internal override int ChildCount => 2;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => BackslashToken,
            1 => TypeToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// One of \s \S \d \D \w \W
/// </summary>
internal sealed class RegexCharacterClassEscapeNode(RegexToken backslashToken, RegexToken typeToken) : RegexTypeEscapeNode(RegexKind.CharacterClassEscape, backslashToken, typeToken)
{
    internal override int ChildCount => 2;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => BackslashToken,
            1 => TypeToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```\cX``` escape
/// </summary>
internal sealed class RegexControlEscapeNode(RegexToken backslashToken, RegexToken typeToken, RegexToken controlToken) : RegexTypeEscapeNode(RegexKind.ControlEscape, backslashToken, typeToken)
{
    internal override int ChildCount => 3;
 
    public RegexToken ControlToken { get; } = controlToken;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => BackslashToken,
            1 => TypeToken,
            2 => ControlToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```\xFF``` escape.
/// </summary>
internal sealed class RegexHexEscapeNode(RegexToken backslashToken, RegexToken typeToken, RegexToken hexText) : RegexTypeEscapeNode(RegexKind.HexEscape, backslashToken, typeToken)
{
    internal override int ChildCount => 3;
 
    public RegexToken HexText { get; } = hexText;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => BackslashToken,
            1 => TypeToken,
            2 => HexText,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```\uFFFF``` escape.
/// </summary>
internal sealed class RegexUnicodeEscapeNode(RegexToken backslashToken, RegexToken typeToken, RegexToken hexText) : RegexTypeEscapeNode(RegexKind.UnicodeEscape, backslashToken, typeToken)
{
    internal override int ChildCount => 3;
 
    public RegexToken HexText { get; } = hexText;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => BackslashToken,
            1 => TypeToken,
            2 => HexText,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```\'name'``` or ```\&lt;name&gt;``` escape.
/// </summary>
internal sealed class RegexCaptureEscapeNode(
    RegexToken backslashToken, RegexToken openToken, RegexToken captureToken, RegexToken closeToken) : RegexEscapeNode(RegexKind.CaptureEscape, backslashToken)
{
    internal override int ChildCount => 4;
 
    public RegexToken OpenToken { get; } = openToken;
    public RegexToken CaptureToken { get; } = captureToken;
    public RegexToken CloseToken { get; } = closeToken;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => BackslashToken,
            1 => OpenToken,
            2 => CaptureToken,
            3 => CloseToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```\k'name'``` or ```\k&lt;name&gt;``` escape.
/// </summary>
internal sealed class RegexKCaptureEscapeNode(
    RegexToken backslashToken, RegexToken typeToken,
    RegexToken openToken, RegexToken captureToken, RegexToken closeToken) : RegexTypeEscapeNode(RegexKind.KCaptureEscape, backslashToken, typeToken)
{
    internal override int ChildCount => 5;
 
    public RegexToken OpenToken { get; } = openToken;
    public RegexToken CaptureToken { get; } = captureToken;
    public RegexToken CloseToken { get; } = closeToken;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => BackslashToken,
            1 => TypeToken,
            2 => OpenToken,
            3 => CaptureToken,
            4 => CloseToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```\1``` escape. In contexts where back-references are not allowed.
/// </summary>
internal sealed class RegexOctalEscapeNode(RegexToken backslashToken, RegexToken octalText) : RegexEscapeNode(RegexKind.OctalEscape, backslashToken)
{
    internal override int ChildCount => 2;
 
    public RegexToken OctalText { get; } = octalText;
 
    internal override RegexNodeOrToken ChildAt(int index)
    {
        switch (index)
        {
            case 0: return BackslashToken;
            case 1: return OctalText;
        }
 
        throw new InvalidOperationException();
    }
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```\1```
/// </summary>
internal sealed class RegexBackreferenceEscapeNode(RegexToken backslashToken, RegexToken numberToken) : RegexEscapeNode(RegexKind.BackreferenceEscape, backslashToken)
{
    internal override int ChildCount => 2;
 
    public RegexToken NumberToken { get; } = numberToken;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => BackslashToken,
            1 => NumberToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}
 
/// <summary>
/// ```\p{...}```
/// </summary>
internal sealed class RegexCategoryEscapeNode : RegexEscapeNode
{
    public RegexCategoryEscapeNode(
        RegexToken backslashToken, RegexToken typeToken, RegexToken openBraceToken, RegexToken categoryToken, RegexToken closeBraceToken)
        : base(RegexKind.CategoryEscape, backslashToken)
    {
        Debug.Assert(openBraceToken.Kind == RegexKind.OpenBraceToken);
        Debug.Assert(closeBraceToken.Kind == RegexKind.CloseBraceToken);
        TypeToken = typeToken;
        OpenBraceToken = openBraceToken;
        CategoryToken = categoryToken;
        CloseBraceToken = closeBraceToken;
    }
 
    public RegexToken TypeToken { get; }
    public RegexToken OpenBraceToken { get; }
    public RegexToken CategoryToken { get; }
    public RegexToken CloseBraceToken { get; }
 
    internal override int ChildCount => 5;
 
    internal override RegexNodeOrToken ChildAt(int index)
        => index switch
        {
            0 => BackslashToken,
            1 => TypeToken,
            2 => OpenBraceToken,
            3 => CategoryToken,
            4 => CloseBraceToken,
            _ => throw new InvalidOperationException(),
        };
 
    public override void Accept(IRegexNodeVisitor visitor)
        => visitor.Visit(this);
}