diff --git a/ConsoleDemo/PrettyPrinter.cs b/ConsoleDemo/PrettyPrinter.cs index 585a1c8..1f2be12 100644 --- a/ConsoleDemo/PrettyPrinter.cs +++ b/ConsoleDemo/PrettyPrinter.cs @@ -196,7 +196,12 @@ namespace ProjectConsole Visit(node.InputDescription); Visit(node.Commas); Visit(node.Body); - OutputKeyword(node.EndKeyword); + Visit(node.EndKeyword); + } + + public override void VisitEndKeyword(EndKeywordSyntaxNode node) + { + OutputKeyword(node.EndKeyword); } public override void VisitFunctionDeclaration(FunctionDeclarationSyntaxNode node) @@ -207,7 +212,7 @@ namespace ProjectConsole Visit(node.InputDescription); Visit(node.Commas); Visit(node.Body); - OutputKeyword(node.EndKeyword); + Visit(node.EndKeyword); } public override void VisitIfStatement(IfStatementSyntaxNode node) diff --git a/Parser.Tests/DiagnosticExtensions.cs b/Parser.Tests/DiagnosticExtensions.cs new file mode 100644 index 0000000..13bac54 --- /dev/null +++ b/Parser.Tests/DiagnosticExtensions.cs @@ -0,0 +1,47 @@ +using System.Linq; + +namespace Parser.Tests +{ + public static class DiagnosticExtensions + { + public static bool IsEquivalentTo(this SyntaxDiagnostic[] actualSequence, params SyntaxDiagnostic[] expectedSequence) + { + if (actualSequence.Length != expectedSequence.Length) + { + return false; + } + + var actualSorted = actualSequence.OrderBy(x => x.Position).ToArray(); + var expectedSorted = expectedSequence.OrderBy(x => x.Position).ToArray(); + for (var i = 0; i < expectedSequence.Length; i++) + { + var expected = expectedSequence[i]; + var actual = actualSequence[i]; + if (expected.Position != actual.Position) + { + return false; + } + + if (expected is MissingTokenSyntaxDiagnostic expectedMissingToken) + { + if (!(actual is MissingTokenSyntaxDiagnostic actualMissingToken)) + { + return false; + } + + if (expectedMissingToken.Kind != actualMissingToken.Kind) + { + return false; + } + } + } + + return true; + } + + public static MissingTokenSyntaxDiagnostic MissingToken(int position, TokenKind kind) + { + return new MissingTokenSyntaxDiagnostic(position, kind); + } + } +} \ No newline at end of file diff --git a/Parser.Tests/MLexerGreenTests.cs b/Parser.Tests/MLexerGreenTests.cs index 21832b7..cca2663 100644 --- a/Parser.Tests/MLexerGreenTests.cs +++ b/Parser.Tests/MLexerGreenTests.cs @@ -15,7 +15,9 @@ namespace Parser.Tests } [Theory] +#pragma warning disable xUnit1019 // MemberData must reference a member providing a valid data type [MemberData(nameof(SingleTokensData))] +#pragma warning restore xUnit1019 // MemberData must reference a member providing a valid data type public void MLexerGreen_Parses_Token(TokenKind kind, string text) { var tokens = ParseText(text); @@ -24,7 +26,9 @@ namespace Parser.Tests } [Theory] +#pragma warning disable xUnit1019 // MemberData must reference a member providing a valid data type [MemberData(nameof(PairTokensData))] +#pragma warning restore xUnit1019 // MemberData must reference a member providing a valid data type public void MLexerGreen_Parses_PairOfTokens(TokenKind kind1, string text1, TokenKind kind2, string text2) { var text = text1 + text2; @@ -35,7 +39,9 @@ namespace Parser.Tests } [Theory] +#pragma warning disable xUnit1019 // MemberData must reference a member providing a valid data type [MemberData(nameof(PairTokensWithSeparatorData))] +#pragma warning restore xUnit1019 // MemberData must reference a member providing a valid data type public void MLexerGreen_Parses_PairOfTokensWithSeparator(TokenKind kind1, string text1, string separatorText, TokenKind kind2, string text2) { var text = text1 + separatorText + text2; @@ -78,17 +84,17 @@ namespace Parser.Tests public static IEnumerable<(TokenKind kind, string text)> GetTokens() { - var fixedTokens = Enum.GetValues(typeof(TokenKind)) - .Cast() - .Select(k => (kind: k, text: SyntaxFacts.GetText(k))) - .Where(t => !(t.text is null)) - .Where(t => !(SyntaxFacts.IsUnaryTokenKind(t.kind) - || SyntaxFacts.IsOpeningToken(t.kind) - || SyntaxFacts.IsClosingToken(t.kind) - || t.kind == TokenKind.ApostropheToken)); - - - var dynamicTokens = new[] + var fixedTokens = + from TokenKind kind in Enum.GetValues(typeof(TokenKind)) + let text = SyntaxFacts.GetText(kind) + where !(text is null) + where !(SyntaxFacts.IsUnaryTokenKind(kind) + || SyntaxFacts.IsOpeningToken(kind) + || SyntaxFacts.IsClosingToken(kind) + || kind == TokenKind.ApostropheToken) + select (kind, text); + + var dynamicTokens = new[] { (TokenKind.IdentifierToken, "a"), (TokenKind.IdentifierToken, "abc"), @@ -105,33 +111,21 @@ namespace Parser.Tests public static IEnumerable<(TokenKind kind1, string text1, TokenKind kind2, string text2)> GetPairsOfTokens() { - foreach (var token1 in GetTokens()) - { - foreach (var token2 in GetTokens()) - { - if (!RequiresSeparator(token1.kind, token2.kind)) - { - yield return (token1.kind, token1.text, token2.kind, token2.text); - } - } - } + return + from token1 in GetTokens() + from token2 in GetTokens() + where !RequiresSeparator(token1.kind, token2.kind) + select (token1.kind, token1.text, token2.kind, token2.text); } public static IEnumerable<(TokenKind kind1, string text1, string separatorText, TokenKind kind2, string text2)> GetPairsOfTokensWithSeparators() { - foreach (var token1 in GetTokens()) - { - foreach (var token2 in GetTokens()) - { - if (RequiresSeparator(token1.kind, token2.kind)) - { - foreach (var separatorText in GetSeparators()) - { - yield return (token1.kind, token1.text, separatorText, token2.kind, token2.text); - } - } - } - } + return + from token1 in GetTokens() + from token2 in GetTokens() + where RequiresSeparator(token1.kind, token2.kind) + from separatorText in GetSeparators() + select (token1.kind, token1.text, separatorText, token2.kind, token2.text); } private static bool RequiresSeparator(TokenKind kind1, TokenKind kind2) diff --git a/Parser.Tests/MParserShould.cs b/Parser.Tests/MParserShould.cs index a149205..91bd393 100644 --- a/Parser.Tests/MParserShould.cs +++ b/Parser.Tests/MParserShould.cs @@ -2,6 +2,8 @@ namespace Parser.Tests { + using static DiagnosticExtensions; + public class MParserShould { private static MParser GetSut(string text) @@ -19,6 +21,11 @@ namespace Parser.Tests var actual = sut.Parse(); var assignment = actual.Root.StatementList[0].AsNode(); Assert.IsType(assignment); + if (assignment is null) + { + throw new System.Exception(); + } + Assert.IsType(((ExpressionStatementSyntaxNode)assignment).Expression); } @@ -30,6 +37,11 @@ namespace Parser.Tests var actual = sut.Parse(); var statement = actual.Root.StatementList[0].AsNode(); Assert.IsType(statement); + if (statement is null) + { + throw new System.Exception(); + } + Assert.IsType(((ExpressionStatementSyntaxNode)statement).Expression); } @@ -41,6 +53,11 @@ namespace Parser.Tests var actual = sut.Parse(); var assignment = actual.Root.StatementList[0].AsNode(); Assert.IsType(assignment); + if (assignment is null) + { + throw new System.Exception(); + } + Assert.IsType(((ExpressionStatementSyntaxNode)assignment).Expression); } @@ -50,7 +67,8 @@ namespace Parser.Tests { var sut = GetSut(text); var actual = sut.Parse(); - Assert.Collection(actual.Diagnostics, item => Assert.Equal("Unexpected token 'SemicolonToken', expected 'IdentifierToken'.", item.Message)); + var diagnostics = actual.Root.GetDiagnostics(); + Assert.True(diagnostics.IsEquivalentTo(MissingToken(4, TokenKind.IdentifierToken))); } [Fact] @@ -60,8 +78,8 @@ namespace Parser.Tests var sut = GetSut(text); var actual = sut.Parse(); var statement = actual.Root.StatementList[0].AsNode() as ExpressionStatementSyntaxNode; - var expression = statement.Expression as BinaryOperationExpressionSyntaxNode; - var lhs = expression.Lhs; + var expression = statement!.Expression as BinaryOperationExpressionSyntaxNode; + var lhs = expression!.Lhs; var operation = expression.Operation; var rhs = expression.Rhs; Assert.Equal(0, lhs.Position); diff --git a/Parser.Tests/Parser.Tests.csproj b/Parser.Tests/Parser.Tests.csproj index 9f96ade..b0bbeec 100644 --- a/Parser.Tests/Parser.Tests.csproj +++ b/Parser.Tests/Parser.Tests.csproj @@ -2,11 +2,16 @@ netcoreapp3.0 false + enable + 8.0 - - - + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + diff --git a/Parser.Tests/ThereAndBackAgain.cs b/Parser.Tests/ThereAndBackAgain.cs index 782f36f..c73faf0 100644 --- a/Parser.Tests/ThereAndBackAgain.cs +++ b/Parser.Tests/ThereAndBackAgain.cs @@ -44,7 +44,9 @@ namespace Parser.Tests } [Theory] +#pragma warning disable xUnit1019 // MemberData must reference a member providing a valid data type [MemberData(nameof(FilesData))] +#pragma warning restore xUnit1019 // MemberData must reference a member providing a valid data type public void TestFile(string fileName) { var text = File.ReadAllText(fileName); diff --git a/Parser/ChildNodesAndTokensList.cs b/Parser/ChildNodesAndTokensList.cs index 59de5f9..a50ed30 100644 --- a/Parser/ChildNodesAndTokensList.cs +++ b/Parser/ChildNodesAndTokensList.cs @@ -68,7 +68,7 @@ namespace Parser internal SyntaxNodeOrToken ThisInternal(int index) { var currentSlotIndex = 0; - GreenNode currentSlot = null; + GreenNode? currentSlot = null; while (true) { currentSlot = _node._green.GetSlot(currentSlotIndex); @@ -84,13 +84,17 @@ namespace Parser if (currentSlot.IsList) { var listSlot = _node.GetNode(currentSlotIndex); + if (listSlot is null) + { + throw new Exception($"Unexpected null in list slot."); + } var red = listSlot.GetNode(index); - if (red != null) + if (!(red is null)) { return red; } // this is a token - return new SyntaxToken(listSlot, listSlot._green.GetSlot(index), _node.GetChildPosition(index)); + return new SyntaxToken(listSlot, listSlot._green.GetSlot(index)!, _node.GetChildPosition(index)); } else { @@ -100,7 +104,7 @@ namespace Parser return red; } // this is a token - return new SyntaxToken(_node, _node._green.GetSlot(currentSlotIndex), _node.GetChildPosition(currentSlotIndex)); + return new SyntaxToken(_node, _node._green.GetSlot(currentSlotIndex)!, _node.GetChildPosition(currentSlotIndex)); } } diff --git a/Parser/Internal/Diagnostic.cs b/Parser/Internal/Diagnostic.cs index cb20f77..dbe5ed4 100644 --- a/Parser/Internal/Diagnostic.cs +++ b/Parser/Internal/Diagnostic.cs @@ -4,7 +4,7 @@ namespace Parser.Internal { public class Diagnostic { - public TextSpan Span { get; } + public TextSpan? Span { get; } public string Message { get; } public Diagnostic(TextSpan span, string message) @@ -12,5 +12,10 @@ namespace Parser.Internal Span = span; Message = message ?? throw new ArgumentNullException(nameof(message)); } + + public Diagnostic(string message) + { + Message = message ?? throw new ArgumentNullException(nameof(message)); + } } } \ No newline at end of file diff --git a/Parser/Internal/DiagnosticsBag.cs b/Parser/Internal/DiagnosticsBag.cs index 39f0fdc..ca0ab3f 100644 --- a/Parser/Internal/DiagnosticsBag.cs +++ b/Parser/Internal/DiagnosticsBag.cs @@ -26,6 +26,12 @@ namespace Parser.Internal _diagnostics.Add(diagnostic); } + private void Report(string message) + { + var diagnostic = new Diagnostic(message); + _diagnostics.Add(diagnostic); + } + internal void ReportUnexpectedEndOfFile(TextSpan span) { Report(span, "Unexpected end of file."); @@ -46,9 +52,9 @@ namespace Parser.Internal Report(span, $"Unknown symbol '{c}'."); } - internal void ReportUnexpectedToken(TextSpan span, TokenKind expected, TokenKind actual) + internal void ReportUnexpectedToken(TokenKind expected, TokenKind actual) { - Report(span, $"Unexpected token '{actual}', expected '{expected}'."); + Report($"Unexpected token '{actual}', expected '{expected}'."); } public IEnumerator GetEnumerator() diff --git a/Parser/Internal/GreenNode.cs b/Parser/Internal/GreenNode.cs index f938acc..dfda086 100644 --- a/Parser/Internal/GreenNode.cs +++ b/Parser/Internal/GreenNode.cs @@ -10,7 +10,10 @@ namespace Parser.Internal { public TokenKind Kind { get; } public int Slots { get; protected set; } - public abstract GreenNode GetSlot(int i); + public abstract GreenNode? GetSlot(int i); + public bool HasDiagnostics { get; } + private static Dictionary diagnosticsTable = new Dictionary(); + private static TokenDiagnostic[] emptyDiagnostics = Array.Empty(); public GreenNode(TokenKind kind) { @@ -23,13 +26,28 @@ namespace Parser.Internal _fullWidth = fullWidth; } + public GreenNode(TokenKind kind, TokenDiagnostic[] diagnostics) + { + Kind = kind; + HasDiagnostics = true; + diagnosticsTable[this] = diagnostics; + } + + public GreenNode(TokenKind kind, int fullWidth, TokenDiagnostic[] diagnostics) + { + Kind = kind; + _fullWidth = fullWidth; + HasDiagnostics = true; + diagnosticsTable[this] = diagnostics; + } + internal abstract Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position); protected int _fullWidth; public int FullWidth => _fullWidth; - protected void AdjustWidth(GreenNode node) + protected void AdjustWidth(GreenNode? node) { if (!(node is null)) { @@ -56,11 +74,6 @@ namespace Parser.Internal internal bool IsMissing => _isMissing; - public override string ToString() - { - return base.ToString(); - } - private void WriteTo(TextWriter writer, bool leading, bool trailing) { var stack = new Stack<(GreenNode node, bool leading, bool trailing)>(); @@ -109,12 +122,12 @@ namespace Parser.Internal return -1; } - private GreenNode GetFirstTerminal() + private GreenNode? GetFirstTerminal() { var current = this; while (true) { - GreenNode next = null; + GreenNode? next = null; if (current.Slots == 0) { return current; @@ -141,12 +154,12 @@ namespace Parser.Internal } } - private GreenNode GetLastTerminal() + private GreenNode? GetLastTerminal() { var current = this; while (true) { - GreenNode next = null; + GreenNode? next = null; if (current.Slots == 0) { return current; @@ -225,5 +238,17 @@ namespace Parser.Internal } } } + + public abstract GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics); + + internal TokenDiagnostic[] GetDiagnostics() + { + if (diagnosticsTable.TryGetValue(this, out var diags)) + { + return diags; + } + + return emptyDiagnostics; + } } } \ No newline at end of file diff --git a/Parser/Internal/GreenNodeExtensions.cs b/Parser/Internal/GreenNodeExtensions.cs new file mode 100644 index 0000000..7e17157 --- /dev/null +++ b/Parser/Internal/GreenNodeExtensions.cs @@ -0,0 +1,14 @@ +using System.Collections.Generic; +using System.Linq; + +namespace Parser.Internal +{ + internal static class GreenNodeExtensions + { + public static TNode WithDiagnostics(this TNode node, params TokenDiagnostic[] diagnostics) + where TNode : GreenNode + { + return (TNode)node.SetDiagnostics(diagnostics.ToArray()); + } + } +} diff --git a/Parser/Internal/MLexerGreen.cs b/Parser/Internal/MLexerGreen.cs index e896b0f..8ff6352 100644 --- a/Parser/Internal/MLexerGreen.cs +++ b/Parser/Internal/MLexerGreen.cs @@ -9,9 +9,9 @@ namespace Parser.Internal { private class TokenInfo { - public TokenKind Kind { get; set; } - public string Text { get; set; } - public string StringValue { get; set; } + public TokenKind Kind { get; set; } = TokenKind.None; + public string Text { get; set; } = ""; + public string StringValue { get; set; } = ""; public double DoubleValue { get; set; } } @@ -25,6 +25,7 @@ namespace Parser.Internal public MLexerGreen(ITextWindow window) { Window = window; + LastToken = SyntaxToken.NoneToken; TokenStack = new Stack(); } diff --git a/Parser/Internal/MParserGreen.cs b/Parser/Internal/MParserGreen.cs index 4db3e52..1591bb2 100644 --- a/Parser/Internal/MParserGreen.cs +++ b/Parser/Internal/MParserGreen.cs @@ -28,13 +28,20 @@ namespace Parser.Internal return token; } + private SyntaxToken CreateMissingToken(TokenKind kind) + { + return TokenFactory + .CreateMissing(kind, null, null) + .WithDiagnostics(TokenDiagnostic.MissingToken(kind)); + } + private SyntaxToken EatToken(TokenKind kind) { var token = CurrentToken; if (token.Kind != kind) { - Diagnostics.ReportUnexpectedToken(token.Span, kind, token.Kind); - return TokenFactory.CreateMissing(kind, null, null); + Diagnostics.ReportUnexpectedToken(kind, token.Kind); + return CreateMissingToken(kind); } _index++; return token; @@ -55,13 +62,13 @@ namespace Parser.Internal var token = CurrentToken; if (token.Kind != TokenKind.IdentifierToken) { - Diagnostics.ReportUnexpectedToken(token.Span, TokenKind.IdentifierToken, token.Kind); + Diagnostics.ReportUnexpectedToken(TokenKind.IdentifierToken, token.Kind); return TokenFactory.CreateMissing(TokenKind.IdentifierToken, null, null); } if (token.Text != s) { - Diagnostics.ReportUnexpectedToken(token.Span, TokenKind.IdentifierToken, token.Kind); + Diagnostics.ReportUnexpectedToken(TokenKind.IdentifierToken, token.Kind); return TokenFactory.CreateMissing(TokenKind.IdentifierToken, null, null); } @@ -69,7 +76,7 @@ namespace Parser.Internal return token; } - private SyntaxToken PossiblyEatIdentifier(string s) + private SyntaxToken? PossiblyEatIdentifier(string s) { var token = CurrentToken; if (token.Kind == TokenKind.IdentifierToken && token.Text == s) @@ -94,7 +101,7 @@ namespace Parser.Internal new List()); } - private SyntaxList ParseFunctionOutputList() + private SyntaxList? ParseFunctionOutputList() { var outputs = new SyntaxListBuilder(); var firstToken = true; @@ -112,7 +119,7 @@ namespace Parser.Internal return outputs.ToList(); } - private FunctionOutputDescriptionSyntaxNode ParseFunctionOutputDescription() + private FunctionOutputDescriptionSyntaxNode? ParseFunctionOutputDescription() { SyntaxToken assignmentSign; var builder = new SyntaxListBuilder(); @@ -180,7 +187,7 @@ namespace Parser.Internal return builder.ToList(); } - private FunctionInputDescriptionSyntaxNode ParseFunctionInputDescription() + private FunctionInputDescriptionSyntaxNode? ParseFunctionInputDescription() { if (CurrentToken.Kind == TokenKind.OpenParenthesisToken) { @@ -206,7 +213,8 @@ namespace Parser.Internal var inputDescription = ParseFunctionInputDescription(); var commas = ParseOptionalCommas(); var body = ParseStatementList(); - var endKeyword = EatPossiblyMissingIdentifier("end"); + var endKeyword = ParseEndKeyword(); + //var endKeyword = return Factory.FunctionDeclarationSyntax( functionKeyword, outputDescription, @@ -216,7 +224,13 @@ namespace Parser.Internal body, endKeyword); } - + + private EndKeywordSyntaxNode? ParseEndKeyword() + { + var keyword = EatPossiblyMissingIdentifier("end"); + return keyword is null ? null : Factory.EndKeywordSyntax(keyword); + } + internal struct ParseOptions { public bool ParsingArrayElements { get; set; } @@ -224,12 +238,12 @@ namespace Parser.Internal public static ParseOptions Default = new ParseOptions { ParsingArrayElements = false }; } - private ExpressionSyntaxNode ParseExpression() + private ExpressionSyntaxNode? ParseExpression() { return ParseExpression(ParseOptions.Default); } - private ExpressionSyntaxNode ParseExpression(ParseOptions options) + private ExpressionSyntaxNode? ParseExpression(ParseOptions options) { return ParseSubExpression(options, SyntaxFacts.Precedence.Expression); } @@ -286,10 +300,10 @@ namespace Parser.Internal return builder.ToList(); } - private ExpressionSyntaxNode ParseTerm(ParseOptions options) + private ExpressionSyntaxNode? ParseTerm(ParseOptions options) { var token = CurrentToken; - ExpressionSyntaxNode expression = null; + ExpressionSyntaxNode? expression = null; switch (token.Kind) { case TokenKind.NumberLiteralToken: @@ -410,6 +424,11 @@ namespace Parser.Internal return Factory.CommandExpressionSyntax(idNameNode, builder.ToList()); } + + if (expression is null) + { + throw new Exception("Command expression identifier cannot be empty."); + } throw new ParsingException($"Unexpected token \"{CurrentToken}\" while parsing expression \"{expression.FullText}\" at {CurrentPosition}."); } @@ -420,6 +439,10 @@ namespace Parser.Internal { var atToken = EatToken(); var baseClassNameWithArguments = ParseExpression(); + if (baseClassNameWithArguments is null) + { + throw new Exception($"Base class name cannot be empty."); + } return Factory.BaseClassInvokationSyntax(methodName, atToken, baseClassNameWithArguments); } if (expression is MemberAccessSyntaxNode memberAccess @@ -427,6 +450,10 @@ namespace Parser.Internal { var atToken = EatToken(); var baseClassNameWithArguments = ParseExpression(); + if (baseClassNameWithArguments is null) + { + throw new Exception($"Base class name cannot be empty."); + } return Factory.BaseClassInvokationSyntax(memberAccess, atToken, baseClassNameWithArguments); } throw new ParsingException($"Unexpected token \"{CurrentToken}\" at {CurrentPosition}."); @@ -442,6 +469,10 @@ namespace Parser.Internal { var openingBracket = EatToken(); var indirectMember = ParseExpression(); + if (indirectMember is null) + { + throw new Exception("Indirect member invokation cannot be empty."); + } var closingBracket = EatToken(TokenKind.CloseParenthesisToken); return Factory.IndirectMemberAccessSyntax( openingBracket, @@ -466,7 +497,12 @@ namespace Parser.Internal firstToken = false; } - builder.Add(ParseExpression()); + var expression = ParseExpression(); + if (expression is null) + { + throw new Exception("Function call parameter cannot be empty."); + } + builder.Add(expression); } return builder.ToList(); @@ -476,6 +512,10 @@ namespace Parser.Internal { var openParen = EatToken(TokenKind.OpenParenthesisToken); var expression = ParseExpression(); + if (expression is null) + { + throw new Exception("Parenthesized expression cannot be empty."); + } var closeParen = EatToken(TokenKind.CloseParenthesisToken); return Factory.ParenthesizedExpressionSyntax( openParen, @@ -514,17 +554,25 @@ namespace Parser.Internal else if (CurrentToken.Kind == TokenKind.OpenParenthesisToken) { var inputs = ParseFunctionInputDescription(); + if (inputs is null) + { + throw new Exception($"Lambda expression inputs cannot be empty."); + } var body = ParseExpression(); + if (body is null) + { + throw new Exception($"Lambda expression body cannot be empty."); + } return Factory.LambdaSyntax(atSign, inputs, body); } throw new ParsingException($"Unexpected token {CurrentToken} while parsing function handle at {CurrentPosition}."); } - private ExpressionSyntaxNode ParseSubExpression( + private ExpressionSyntaxNode? ParseSubExpression( ParseOptions options, SyntaxFacts.Precedence precedence) { - ExpressionSyntaxNode lhs; + ExpressionSyntaxNode? lhs; if (SyntaxFacts.IsUnaryOperator(CurrentToken.Kind)) { var operation = EatToken(); @@ -551,6 +599,10 @@ namespace Parser.Internal else { lhs = ParseTerm(options); + if (lhs is null) + { + throw new Exception("Left-hand side in subexpression cannot be empty."); + } } while (true) @@ -579,9 +631,10 @@ namespace Parser.Internal } else { - rhs = null; + throw new Exception("Right-hand side in subexpression cannot be empty."); } } + if (token.Kind == TokenKind.EqualsToken) { lhs = Factory.AssignmentExpressionSyntax(lhs, token, rhs); @@ -627,6 +680,10 @@ namespace Parser.Internal { var caseKeyword = EatIdentifier("case"); var caseId = ParseExpression(); + if (caseId is null) + { + throw new Exception("Case label cannot be empty."); + } var commas = ParseOptionalCommas(); var statementList = ParseStatementList(); return Factory.SwitchCaseSyntax(caseKeyword, caseId, commas, statementList); @@ -636,6 +693,10 @@ namespace Parser.Internal { var switchKeyword = EatIdentifier("switch"); var expression = ParseExpression(); + if (expression is null) + { + throw new Exception("Match expression in switch statement cannot be empty."); + } var commas = ParseOptionalCommas(); var builder = new SyntaxListBuilder(); while (IsIdentifier(CurrentToken, "case")) @@ -655,6 +716,11 @@ namespace Parser.Internal { var whileKeyword = EatIdentifier("while"); var condition = ParseExpression(); + if (condition is null) + { + throw new Exception("Condition in while statement cannot be empty."); + } + var commas = ParseOptionalCommas(); var body = ParseStatementList(); var endKeyword = EatIdentifier("end"); @@ -670,6 +736,10 @@ namespace Parser.Internal { var elseifKeyword = EatIdentifier("elseif"); var condition = ParseExpression(); + if (condition is null) + { + throw new Exception("Condition in elseif clause cannot be empty."); + } var commas = ParseOptionalCommas(); var body = ParseStatementList(); return Factory.ElseifClause(elseifKeyword, condition, commas, body); @@ -686,10 +756,14 @@ namespace Parser.Internal { var ifKeyword = EatIdentifier(); var condition = ParseExpression(); + if (condition is null) + { + throw new Exception("Condition in if statement cannot be empty."); + } var commas = ParseOptionalSemicolonsOrCommas(); var body = ParseStatementList(); var elseifClauses = new SyntaxListBuilder(); - ElseClause elseClause = null; + ElseClause? elseClause = null; while (true) { var token = CurrentToken; @@ -740,7 +814,7 @@ namespace Parser.Internal endKeyword); } - private CatchClauseSyntaxNode ParseCatchClause() + private CatchClauseSyntaxNode? ParseCatchClause() { if (IsIdentifier(CurrentToken, "catch")) { @@ -766,15 +840,24 @@ namespace Parser.Internal private ExpressionStatementSyntaxNode ParseExpressionStatement() { var expression = ParseExpression(); + if (expression is null) + { + throw new Exception("Expression statement cannot be empty."); + } + return Factory.ExpressionStatementSyntax(expression); } - private AttributeAssignmentSyntaxNode ParseAttributeAssignment() + private AttributeAssignmentSyntaxNode? ParseAttributeAssignment() { if (CurrentToken.Kind == TokenKind.EqualsToken) { var assignmentSign = EatToken(); var value = ParseExpression(); + if (value is null) + { + throw new Exception("Right-hand side in attribute assignment cannot be empty."); + } return Factory.AttributeAssignmentSyntax(assignmentSign, value); } @@ -845,7 +928,7 @@ namespace Parser.Internal var inputDescription = ParseFunctionInputDescription(); var commas = ParseOptionalCommas(); var body = ParseStatementList(); - var endKeyword = PossiblyEatIdentifier("end"); + var endKeyword = ParseEndKeyword(); return Factory.MethodDefinitionSyntax( functionKeyword, outputDescription, @@ -859,7 +942,7 @@ namespace Parser.Internal private MethodsListSyntaxNode ParseMethods() { var methodsKeyword = EatToken(); - AttributeListSyntaxNode attributes = null; + AttributeListSyntaxNode? attributes = null; if (CurrentToken.Kind == TokenKind.OpenParenthesisToken) { attributes = ParseAttributesList(); @@ -876,7 +959,7 @@ namespace Parser.Internal return Factory.MethodsListSyntax(methodsKeyword, attributes, builder.ToList(), endKeyword); } - private GreenNode ParsePropertyDeclaration() + private GreenNode? ParsePropertyDeclaration() { if (CurrentToken.Kind == TokenKind.CommaToken) { @@ -885,7 +968,7 @@ namespace Parser.Internal return ParseStatement(); } - private SyntaxNode ParseEventDeclaration() + private SyntaxNode? ParseEventDeclaration() { return ParseStatement(); } @@ -893,7 +976,7 @@ namespace Parser.Internal private PropertiesListSyntaxNode ParseProperties() { var propertiesKeyword = EatToken(); - AttributeListSyntaxNode attributes = null; + AttributeListSyntaxNode? attributes = null; if (CurrentToken.Kind == TokenKind.OpenParenthesisToken) { attributes = ParseAttributesList(); @@ -902,14 +985,19 @@ namespace Parser.Internal var builder = new SyntaxListBuilder(); while (!IsIdentifier(CurrentToken, "end")) { - builder.Add(ParsePropertyDeclaration()); + var declaration = ParsePropertyDeclaration(); + if (declaration is null) + { + throw new Exception("Property declaration cannot be null."); + } + builder.Add(declaration); } var endKeyword = EatToken(); return Factory.PropertiesListSyntax(propertiesKeyword, attributes, builder.ToList(), endKeyword); } - private EnumerationItemValueSyntaxNode ParseEnumerationValue() + private EnumerationItemValueSyntaxNode? ParseEnumerationValue() { if (CurrentToken.Kind == TokenKind.OpenParenthesisToken) { @@ -920,7 +1008,12 @@ namespace Parser.Internal while (CurrentToken.Kind == TokenKind.CommaToken) { builder.Add(EatToken()); - builder.Add(ParseExpression()); + var nextExpression = ParseExpression(); + if (nextExpression is null) + { + throw new Exception("Enumeration identifier cannot be empty."); + } + builder.Add(nextExpression); } var closingBracket = EatToken(TokenKind.CloseParenthesisToken); return Factory.EnumerationItemValueSyntax(openingBracket, builder.ToList(), closingBracket); @@ -940,7 +1033,7 @@ namespace Parser.Internal { var enumerationKeyword = EatToken(); var builder = new SyntaxListBuilder(); - AttributeListSyntaxNode attributes = null; + AttributeListSyntaxNode? attributes = null; if (CurrentToken.Kind == TokenKind.OpenParenthesisToken) { attributes = ParseAttributesList(); @@ -962,7 +1055,7 @@ namespace Parser.Internal private SyntaxNode ParseEvents() { var eventsKeyword = EatToken(); - AttributeListSyntaxNode attributes = null; + AttributeListSyntaxNode? attributes = null; if (CurrentToken.Kind == TokenKind.OpenParenthesisToken) { attributes = ParseAttributesList(); @@ -971,7 +1064,12 @@ namespace Parser.Internal var builder = new SyntaxListBuilder(); while (!IsIdentifier(CurrentToken, "end")) { - builder.Add(ParseEventDeclaration()); + var eventDeclaration = ParseEventDeclaration(); + if (eventDeclaration is null) + { + throw new Exception("Event declaration cannot be empty."); + } + builder.Add(eventDeclaration); } var endKeyword = EatToken(); @@ -1001,13 +1099,13 @@ namespace Parser.Internal private StatementSyntaxNode ParseClassDeclaration() { var classdefKeyword = EatToken(); - AttributeListSyntaxNode attributes = null; + AttributeListSyntaxNode? attributes = null; if (CurrentToken.Kind == TokenKind.OpenParenthesisToken) { attributes = ParseAttributesList(); } var className = Factory.IdentifierNameSyntax(EatToken(TokenKind.IdentifierToken)); - BaseClassListSyntaxNode baseClassList = null; + BaseClassListSyntaxNode? baseClassList = null; if (CurrentToken.Kind == TokenKind.LessToken) { baseClassList = ParseBaseClassList(); @@ -1052,7 +1150,7 @@ namespace Parser.Internal endKeyword); } - private StatementSyntaxNode ParseStatement() + private StatementSyntaxNode? ParseStatement() { if (CurrentToken.Kind == TokenKind.IdentifierToken) { @@ -1120,5 +1218,11 @@ namespace Parser.Internal var endOfFileToken = EatToken(); return Factory.FileSyntax(statementList, endOfFileToken); } + + public RootSyntaxNode ParseRoot() + { + var file = ParseFile(); + return Factory.RootSyntax(file); + } } } \ No newline at end of file diff --git a/Parser/Internal/SyntaxFactory.Generated.cs b/Parser/Internal/SyntaxFactory.Generated.cs index b6f42c2..833aaf2 100644 --- a/Parser/Internal/SyntaxFactory.Generated.cs +++ b/Parser/Internal/SyntaxFactory.Generated.cs @@ -1,3 +1,4 @@ +#nullable enable namespace Parser.Internal { internal partial class SyntaxFactory @@ -13,12 +14,12 @@ namespace Parser.Internal public FunctionDeclarationSyntaxNode FunctionDeclarationSyntax( SyntaxToken functionKeyword, - FunctionOutputDescriptionSyntaxNode outputDescription, + FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, - FunctionInputDescriptionSyntaxNode inputDescription, + FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, - SyntaxToken endKeyword) + EndKeywordSyntaxNode? endKeyword) { return new FunctionDeclarationSyntaxNode( functionKeyword, @@ -121,7 +122,7 @@ namespace Parser.Internal SyntaxList optionalCommas, SyntaxList body, SyntaxList elseifClauses, - ElseClause elseClause, + ElseClause? elseClause, SyntaxToken endKeyword) { return new IfStatementSyntaxNode( @@ -172,7 +173,7 @@ namespace Parser.Internal public TryCatchStatementSyntaxNode TryCatchStatementSyntax( SyntaxToken tryKeyword, SyntaxList tryBody, - CatchClauseSyntaxNode catchClause, + CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword) { return new TryCatchStatementSyntaxNode( @@ -404,7 +405,7 @@ namespace Parser.Internal public AttributeSyntaxNode AttributeSyntax( IdentifierNameSyntaxNode name, - AttributeAssignmentSyntaxNode assignment) + AttributeAssignmentSyntaxNode? assignment) { return new AttributeSyntaxNode( name, @@ -424,12 +425,12 @@ namespace Parser.Internal public MethodDefinitionSyntaxNode MethodDefinitionSyntax( SyntaxToken functionKeyword, - FunctionOutputDescriptionSyntaxNode outputDescription, + FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, - FunctionInputDescriptionSyntaxNode inputDescription, + FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, - SyntaxToken endKeyword) + EndKeywordSyntaxNode? endKeyword) { return new MethodDefinitionSyntaxNode( functionKeyword, @@ -442,9 +443,9 @@ namespace Parser.Internal } public AbstractMethodDeclarationSyntaxNode AbstractMethodDeclarationSyntax( - FunctionOutputDescriptionSyntaxNode outputDescription, + FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, - FunctionInputDescriptionSyntaxNode inputDescription) + FunctionInputDescriptionSyntaxNode? inputDescription) { return new AbstractMethodDeclarationSyntaxNode( outputDescription, @@ -454,7 +455,7 @@ namespace Parser.Internal public MethodsListSyntaxNode MethodsListSyntax( SyntaxToken methodsKeyword, - AttributeListSyntaxNode attributes, + AttributeListSyntaxNode? attributes, SyntaxList methods, SyntaxToken endKeyword) { @@ -467,7 +468,7 @@ namespace Parser.Internal public PropertiesListSyntaxNode PropertiesListSyntax( SyntaxToken propertiesKeyword, - AttributeListSyntaxNode attributes, + AttributeListSyntaxNode? attributes, SyntaxList properties, SyntaxToken endKeyword) { @@ -489,9 +490,9 @@ namespace Parser.Internal public ClassDeclarationSyntaxNode ClassDeclarationSyntax( SyntaxToken classdefKeyword, - AttributeListSyntaxNode attributes, + AttributeListSyntaxNode? attributes, IdentifierNameSyntaxNode className, - BaseClassListSyntaxNode baseClassList, + BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword) { @@ -517,7 +518,7 @@ namespace Parser.Internal public EnumerationItemSyntaxNode EnumerationItemSyntax( IdentifierNameSyntaxNode name, - EnumerationItemValueSyntaxNode values, + EnumerationItemValueSyntaxNode? values, SyntaxList commas) { return new EnumerationItemSyntaxNode( @@ -528,7 +529,7 @@ namespace Parser.Internal public EnumerationListSyntaxNode EnumerationListSyntax( SyntaxToken enumerationKeyword, - AttributeListSyntaxNode attributes, + AttributeListSyntaxNode? attributes, SyntaxList items, SyntaxToken endKeyword) { @@ -541,7 +542,7 @@ namespace Parser.Internal public EventsListSyntaxNode EventsListSyntax( SyntaxToken eventsKeyword, - AttributeListSyntaxNode attributes, + AttributeListSyntaxNode? attributes, SyntaxList events, SyntaxToken endKeyword) { @@ -551,5 +552,12 @@ namespace Parser.Internal events, endKeyword); } + + public EndKeywordSyntaxNode EndKeywordSyntax( + SyntaxToken endKeyword) + { + return new EndKeywordSyntaxNode( + endKeyword); + } } } \ No newline at end of file diff --git a/Parser/Internal/SyntaxFactory.cs b/Parser/Internal/SyntaxFactory.cs index 83a9d8b..8c86a6a 100644 --- a/Parser/Internal/SyntaxFactory.cs +++ b/Parser/Internal/SyntaxFactory.cs @@ -2,5 +2,9 @@ { internal partial class SyntaxFactory { + public RootSyntaxNode RootSyntax(FileSyntaxNode file) + { + return new RootSyntaxNode(file); + } } } \ No newline at end of file diff --git a/Parser/Internal/SyntaxFacts.cs b/Parser/Internal/SyntaxFacts.cs index b2f6c1d..4fd28ca 100644 --- a/Parser/Internal/SyntaxFacts.cs +++ b/Parser/Internal/SyntaxFacts.cs @@ -155,7 +155,7 @@ namespace Parser.Internal } } - private static readonly string[] StringFromKind = + private static readonly string?[] StringFromKind = { null, // None = 0, null, // BadToken = 1, @@ -210,7 +210,7 @@ namespace Parser.Internal "?", // UnaryQuestionMark = 60, }; - public static string GetText(TokenKind kind) + public static string? GetText(TokenKind kind) { if ((int) kind < (int) TokenKind.File) { diff --git a/Parser/Internal/SyntaxList.cs b/Parser/Internal/SyntaxList.cs index 033c143..5a5fbd7 100644 --- a/Parser/Internal/SyntaxList.cs +++ b/Parser/Internal/SyntaxList.cs @@ -5,7 +5,7 @@ namespace Parser.Internal { internal class SyntaxList : SyntaxNode { - private readonly GreenNode[] _elements; + internal readonly GreenNode[] _elements; protected SyntaxList(GreenNode[] elements) : base(TokenKind.List) { @@ -17,21 +17,46 @@ namespace Parser.Internal } } - public override GreenNode GetSlot(int i) + protected SyntaxList( + GreenNode[] elements, + TokenDiagnostic[] diagnostics) + : base(TokenKind.List, diagnostics) + { + Slots = elements.Length; + _elements = elements; + foreach (var element in elements) + { + this.AdjustWidth(element); + } + } + + public GreenNode GetListSlot(int i) { return _elements[i]; } + public override GreenNode? GetSlot(int i) + { + return GetListSlot(i); + } + public static SyntaxList List(GreenNode[] elements) { return new SyntaxList(elements); } + public static SyntaxList EmptyList { get; } = new SyntaxList(new GreenNode[] { }); + public override bool IsList => true; internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.SyntaxNodeOrTokenList(parent, this, position); } + + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new SyntaxList(_elements, diagnostics); + } } } \ No newline at end of file diff --git a/Parser/Internal/SyntaxListBuilder.cs b/Parser/Internal/SyntaxListBuilder.cs index 15567ce..f9f7e04 100644 --- a/Parser/Internal/SyntaxListBuilder.cs +++ b/Parser/Internal/SyntaxListBuilder.cs @@ -20,14 +20,14 @@ namespace Parser.Internal { for (var i = 0; i < list.Slots; i++) { - var element = list.GetSlot(i); + var element = list.GetListSlot(i); _list.Add(element); } } public SyntaxList ToList() { - return _list.Count == 0 ? null : SyntaxList.List(_list.ToArray()); + return _list.Count == 0 ? SyntaxList.EmptyList : SyntaxList.List(_list.ToArray()); } } } \ No newline at end of file diff --git a/Parser/Internal/SyntaxListBuilder`1.cs b/Parser/Internal/SyntaxListBuilder`1.cs index 6f7edb8..db71907 100644 --- a/Parser/Internal/SyntaxListBuilder`1.cs +++ b/Parser/Internal/SyntaxListBuilder`1.cs @@ -18,7 +18,7 @@ namespace Parser.Internal public SyntaxList ToList() { - return _list.Count == 0 ? null : SyntaxList.List(_list.ToArray()); + return _list.Count == 0 ? SyntaxList.Empty : SyntaxList.List(_list.ToArray()); } } diff --git a/Parser/Internal/SyntaxList`1.cs b/Parser/Internal/SyntaxList`1.cs index 2315ffc..21ce891 100644 --- a/Parser/Internal/SyntaxList`1.cs +++ b/Parser/Internal/SyntaxList`1.cs @@ -1,4 +1,6 @@ -namespace Parser.Internal +using System.Linq; + +namespace Parser.Internal { internal class SyntaxList : SyntaxNode where T : GreenNode { @@ -14,9 +16,19 @@ } } - public override GreenNode GetSlot(int i) + protected SyntaxList(T[] list, TokenDiagnostic[] diagnostics) : base(TokenKind.List, diagnostics) { - return (T)_list.GetSlot(i); + Slots = list.Length; + _list = SyntaxList.List(list); + foreach (var element in list) + { + this.AdjustWidth(element); + } + } + + public override GreenNode? GetSlot(int i) + { + return (T)_list.GetListSlot(i); } public static SyntaxList List(T[] elements) @@ -24,11 +36,18 @@ return new SyntaxList(elements); } + public static SyntaxList Empty => new SyntaxList(new T[] { }); + public override bool IsList => true; internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.SyntaxNodeOrTokenList(parent, this, position); } + + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new SyntaxList(_list._elements.Select(x => (T)x).ToArray(), diagnostics); + } } } \ No newline at end of file diff --git a/Parser/Internal/SyntaxNode.Generated.cs b/Parser/Internal/SyntaxNode.Generated.cs index baf7e9f..594154d 100644 --- a/Parser/Internal/SyntaxNode.Generated.cs +++ b/Parser/Internal/SyntaxNode.Generated.cs @@ -1,3 +1,4 @@ +#nullable enable namespace Parser.Internal { internal class FileSyntaxNode : SyntaxNode @@ -9,7 +10,18 @@ namespace Parser.Internal SyntaxList statementList, SyntaxToken endOfFile) : base(TokenKind.File) { + Slots = 2; + this.AdjustWidth(statementList); + _statementList = statementList; + this.AdjustWidth(endOfFile); + _endOfFile = endOfFile; + } + internal FileSyntaxNode( + SyntaxList statementList, + SyntaxToken endOfFile, + TokenDiagnostic[] diagnostics) : base(TokenKind.File, diagnostics) + { Slots = 2; this.AdjustWidth(statementList); _statementList = statementList; @@ -22,7 +34,12 @@ namespace Parser.Internal return new Parser.FileSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new FileSyntaxNode(_statementList, _endOfFile, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -36,23 +53,49 @@ namespace Parser.Internal internal class FunctionDeclarationSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _functionKeyword; - internal readonly FunctionOutputDescriptionSyntaxNode _outputDescription; + internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription; internal readonly SyntaxToken _name; - internal readonly FunctionInputDescriptionSyntaxNode _inputDescription; + internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription; internal readonly SyntaxList _commas; internal readonly SyntaxList _body; - internal readonly SyntaxToken _endKeyword; + internal readonly EndKeywordSyntaxNode? _endKeyword; internal FunctionDeclarationSyntaxNode( SyntaxToken functionKeyword, - FunctionOutputDescriptionSyntaxNode outputDescription, + FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, - FunctionInputDescriptionSyntaxNode inputDescription, + FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, - SyntaxToken endKeyword) : base(TokenKind.FunctionDeclaration) + EndKeywordSyntaxNode? endKeyword) : base(TokenKind.FunctionDeclaration) { + Slots = 7; + this.AdjustWidth(functionKeyword); + _functionKeyword = functionKeyword; + this.AdjustWidth(outputDescription); + _outputDescription = outputDescription; + this.AdjustWidth(name); + _name = name; + this.AdjustWidth(inputDescription); + _inputDescription = inputDescription; + this.AdjustWidth(commas); + _commas = commas; + this.AdjustWidth(body); + _body = body; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal FunctionDeclarationSyntaxNode( + SyntaxToken functionKeyword, + FunctionOutputDescriptionSyntaxNode? outputDescription, + SyntaxToken name, + FunctionInputDescriptionSyntaxNode? inputDescription, + SyntaxList commas, + SyntaxList body, + EndKeywordSyntaxNode? endKeyword, + TokenDiagnostic[] diagnostics) : base(TokenKind.FunctionDeclaration, diagnostics) + { Slots = 7; this.AdjustWidth(functionKeyword); _functionKeyword = functionKeyword; @@ -75,7 +118,12 @@ namespace Parser.Internal return new Parser.FunctionDeclarationSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new FunctionDeclarationSyntaxNode(_functionKeyword, _outputDescription, _name, _inputDescription, _commas, _body, _endKeyword, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -100,7 +148,18 @@ namespace Parser.Internal SyntaxList outputList, SyntaxToken assignmentSign) : base(TokenKind.FunctionOutputDescription) { + Slots = 2; + this.AdjustWidth(outputList); + _outputList = outputList; + this.AdjustWidth(assignmentSign); + _assignmentSign = assignmentSign; + } + internal FunctionOutputDescriptionSyntaxNode( + SyntaxList outputList, + SyntaxToken assignmentSign, + TokenDiagnostic[] diagnostics) : base(TokenKind.FunctionOutputDescription, diagnostics) + { Slots = 2; this.AdjustWidth(outputList); _outputList = outputList; @@ -113,7 +172,12 @@ namespace Parser.Internal return new Parser.FunctionOutputDescriptionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new FunctionOutputDescriptionSyntaxNode(_outputList, _assignmentSign, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -135,7 +199,21 @@ namespace Parser.Internal SyntaxList parameterList, SyntaxToken closingBracket) : base(TokenKind.FunctionInputDescription) { + Slots = 3; + this.AdjustWidth(openingBracket); + _openingBracket = openingBracket; + this.AdjustWidth(parameterList); + _parameterList = parameterList; + this.AdjustWidth(closingBracket); + _closingBracket = closingBracket; + } + internal FunctionInputDescriptionSyntaxNode( + SyntaxToken openingBracket, + SyntaxList parameterList, + SyntaxToken closingBracket, + TokenDiagnostic[] diagnostics) : base(TokenKind.FunctionInputDescription, diagnostics) + { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; @@ -150,7 +228,12 @@ namespace Parser.Internal return new Parser.FunctionInputDescriptionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new FunctionInputDescriptionSyntaxNode(_openingBracket, _parameterList, _closingBracket, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -177,7 +260,27 @@ namespace Parser.Internal SyntaxList cases, SyntaxToken endKeyword) : base(TokenKind.SwitchStatement) { + Slots = 5; + this.AdjustWidth(switchKeyword); + _switchKeyword = switchKeyword; + this.AdjustWidth(switchExpression); + _switchExpression = switchExpression; + this.AdjustWidth(optionalCommas); + _optionalCommas = optionalCommas; + this.AdjustWidth(cases); + _cases = cases; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal SwitchStatementSyntaxNode( + SyntaxToken switchKeyword, + ExpressionSyntaxNode switchExpression, + SyntaxList optionalCommas, + SyntaxList cases, + SyntaxToken endKeyword, + TokenDiagnostic[] diagnostics) : base(TokenKind.SwitchStatement, diagnostics) + { Slots = 5; this.AdjustWidth(switchKeyword); _switchKeyword = switchKeyword; @@ -196,7 +299,12 @@ namespace Parser.Internal return new Parser.SwitchStatementSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new SwitchStatementSyntaxNode(_switchKeyword, _switchExpression, _optionalCommas, _cases, _endKeyword, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -223,7 +331,24 @@ namespace Parser.Internal SyntaxList optionalCommas, SyntaxList body) : base(TokenKind.SwitchCase) { + Slots = 4; + this.AdjustWidth(caseKeyword); + _caseKeyword = caseKeyword; + this.AdjustWidth(caseIdentifier); + _caseIdentifier = caseIdentifier; + this.AdjustWidth(optionalCommas); + _optionalCommas = optionalCommas; + this.AdjustWidth(body); + _body = body; + } + internal SwitchCaseSyntaxNode( + SyntaxToken caseKeyword, + ExpressionSyntaxNode caseIdentifier, + SyntaxList optionalCommas, + SyntaxList body, + TokenDiagnostic[] diagnostics) : base(TokenKind.SwitchCase, diagnostics) + { Slots = 4; this.AdjustWidth(caseKeyword); _caseKeyword = caseKeyword; @@ -240,7 +365,12 @@ namespace Parser.Internal return new Parser.SwitchCaseSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new SwitchCaseSyntaxNode(_caseKeyword, _caseIdentifier, _optionalCommas, _body, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -268,7 +398,27 @@ namespace Parser.Internal SyntaxList body, SyntaxToken endKeyword) : base(TokenKind.WhileStatement) { + Slots = 5; + this.AdjustWidth(whileKeyword); + _whileKeyword = whileKeyword; + this.AdjustWidth(condition); + _condition = condition; + this.AdjustWidth(optionalCommas); + _optionalCommas = optionalCommas; + this.AdjustWidth(body); + _body = body; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal WhileStatementSyntaxNode( + SyntaxToken whileKeyword, + ExpressionSyntaxNode condition, + SyntaxList optionalCommas, + SyntaxList body, + SyntaxToken endKeyword, + TokenDiagnostic[] diagnostics) : base(TokenKind.WhileStatement, diagnostics) + { Slots = 5; this.AdjustWidth(whileKeyword); _whileKeyword = whileKeyword; @@ -287,7 +437,12 @@ namespace Parser.Internal return new Parser.WhileStatementSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new WhileStatementSyntaxNode(_whileKeyword, _condition, _optionalCommas, _body, _endKeyword, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -314,7 +469,24 @@ namespace Parser.Internal SyntaxList optionalCommas, SyntaxList body) : base(TokenKind.ElseifClause) { + Slots = 4; + this.AdjustWidth(elseifKeyword); + _elseifKeyword = elseifKeyword; + this.AdjustWidth(condition); + _condition = condition; + this.AdjustWidth(optionalCommas); + _optionalCommas = optionalCommas; + this.AdjustWidth(body); + _body = body; + } + internal ElseifClause( + SyntaxToken elseifKeyword, + ExpressionSyntaxNode condition, + SyntaxList optionalCommas, + SyntaxList body, + TokenDiagnostic[] diagnostics) : base(TokenKind.ElseifClause, diagnostics) + { Slots = 4; this.AdjustWidth(elseifKeyword); _elseifKeyword = elseifKeyword; @@ -331,7 +503,12 @@ namespace Parser.Internal return new Parser.ElseifClause(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ElseifClause(_elseifKeyword, _condition, _optionalCommas, _body, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -353,7 +530,18 @@ namespace Parser.Internal SyntaxToken elseKeyword, SyntaxList body) : base(TokenKind.ElseClause) { + Slots = 2; + this.AdjustWidth(elseKeyword); + _elseKeyword = elseKeyword; + this.AdjustWidth(body); + _body = body; + } + internal ElseClause( + SyntaxToken elseKeyword, + SyntaxList body, + TokenDiagnostic[] diagnostics) : base(TokenKind.ElseClause, diagnostics) + { Slots = 2; this.AdjustWidth(elseKeyword); _elseKeyword = elseKeyword; @@ -366,7 +554,12 @@ namespace Parser.Internal return new Parser.ElseClause(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ElseClause(_elseKeyword, _body, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -384,7 +577,7 @@ namespace Parser.Internal internal readonly SyntaxList _optionalCommas; internal readonly SyntaxList _body; internal readonly SyntaxList _elseifClauses; - internal readonly ElseClause _elseClause; + internal readonly ElseClause? _elseClause; internal readonly SyntaxToken _endKeyword; internal IfStatementSyntaxNode( @@ -393,10 +586,36 @@ namespace Parser.Internal SyntaxList optionalCommas, SyntaxList body, SyntaxList elseifClauses, - ElseClause elseClause, + ElseClause? elseClause, SyntaxToken endKeyword) : base(TokenKind.IfStatement) { + Slots = 7; + this.AdjustWidth(ifKeyword); + _ifKeyword = ifKeyword; + this.AdjustWidth(condition); + _condition = condition; + this.AdjustWidth(optionalCommas); + _optionalCommas = optionalCommas; + this.AdjustWidth(body); + _body = body; + this.AdjustWidth(elseifClauses); + _elseifClauses = elseifClauses; + this.AdjustWidth(elseClause); + _elseClause = elseClause; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal IfStatementSyntaxNode( + SyntaxToken ifKeyword, + ExpressionSyntaxNode condition, + SyntaxList optionalCommas, + SyntaxList body, + SyntaxList elseifClauses, + ElseClause? elseClause, + SyntaxToken endKeyword, + TokenDiagnostic[] diagnostics) : base(TokenKind.IfStatement, diagnostics) + { Slots = 7; this.AdjustWidth(ifKeyword); _ifKeyword = ifKeyword; @@ -419,7 +638,12 @@ namespace Parser.Internal return new Parser.IfStatementSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new IfStatementSyntaxNode(_ifKeyword, _condition, _optionalCommas, _body, _elseifClauses, _elseClause, _endKeyword, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -450,7 +674,27 @@ namespace Parser.Internal SyntaxList body, SyntaxToken endKeyword) : base(TokenKind.ForStatement) { + Slots = 5; + this.AdjustWidth(forKeyword); + _forKeyword = forKeyword; + this.AdjustWidth(assignment); + _assignment = assignment; + this.AdjustWidth(optionalCommas); + _optionalCommas = optionalCommas; + this.AdjustWidth(body); + _body = body; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal ForStatementSyntaxNode( + SyntaxToken forKeyword, + AssignmentExpressionSyntaxNode assignment, + SyntaxList optionalCommas, + SyntaxList body, + SyntaxToken endKeyword, + TokenDiagnostic[] diagnostics) : base(TokenKind.ForStatement, diagnostics) + { Slots = 5; this.AdjustWidth(forKeyword); _forKeyword = forKeyword; @@ -469,7 +713,12 @@ namespace Parser.Internal return new Parser.ForStatementSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ForStatementSyntaxNode(_forKeyword, _assignment, _optionalCommas, _body, _endKeyword, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -494,7 +743,21 @@ namespace Parser.Internal SyntaxToken assignmentSign, ExpressionSyntaxNode rhs) : base(TokenKind.AssignmentExpression) { + Slots = 3; + this.AdjustWidth(lhs); + _lhs = lhs; + this.AdjustWidth(assignmentSign); + _assignmentSign = assignmentSign; + this.AdjustWidth(rhs); + _rhs = rhs; + } + internal AssignmentExpressionSyntaxNode( + ExpressionSyntaxNode lhs, + SyntaxToken assignmentSign, + ExpressionSyntaxNode rhs, + TokenDiagnostic[] diagnostics) : base(TokenKind.AssignmentExpression, diagnostics) + { Slots = 3; this.AdjustWidth(lhs); _lhs = lhs; @@ -509,7 +772,12 @@ namespace Parser.Internal return new Parser.AssignmentExpressionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new AssignmentExpressionSyntaxNode(_lhs, _assignmentSign, _rhs, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -530,7 +798,18 @@ namespace Parser.Internal SyntaxToken catchKeyword, SyntaxList catchBody) : base(TokenKind.CatchClause) { + Slots = 2; + this.AdjustWidth(catchKeyword); + _catchKeyword = catchKeyword; + this.AdjustWidth(catchBody); + _catchBody = catchBody; + } + internal CatchClauseSyntaxNode( + SyntaxToken catchKeyword, + SyntaxList catchBody, + TokenDiagnostic[] diagnostics) : base(TokenKind.CatchClause, diagnostics) + { Slots = 2; this.AdjustWidth(catchKeyword); _catchKeyword = catchKeyword; @@ -543,7 +822,12 @@ namespace Parser.Internal return new Parser.CatchClauseSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new CatchClauseSyntaxNode(_catchKeyword, _catchBody, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -558,16 +842,33 @@ namespace Parser.Internal { internal readonly SyntaxToken _tryKeyword; internal readonly SyntaxList _tryBody; - internal readonly CatchClauseSyntaxNode _catchClause; + internal readonly CatchClauseSyntaxNode? _catchClause; internal readonly SyntaxToken _endKeyword; internal TryCatchStatementSyntaxNode( SyntaxToken tryKeyword, SyntaxList tryBody, - CatchClauseSyntaxNode catchClause, + CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword) : base(TokenKind.TryCatchStatement) { + Slots = 4; + this.AdjustWidth(tryKeyword); + _tryKeyword = tryKeyword; + this.AdjustWidth(tryBody); + _tryBody = tryBody; + this.AdjustWidth(catchClause); + _catchClause = catchClause; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal TryCatchStatementSyntaxNode( + SyntaxToken tryKeyword, + SyntaxList tryBody, + CatchClauseSyntaxNode? catchClause, + SyntaxToken endKeyword, + TokenDiagnostic[] diagnostics) : base(TokenKind.TryCatchStatement, diagnostics) + { Slots = 4; this.AdjustWidth(tryKeyword); _tryKeyword = tryKeyword; @@ -584,7 +885,12 @@ namespace Parser.Internal return new Parser.TryCatchStatementSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new TryCatchStatementSyntaxNode(_tryKeyword, _tryBody, _catchClause, _endKeyword, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -604,7 +910,15 @@ namespace Parser.Internal internal ExpressionStatementSyntaxNode( ExpressionSyntaxNode expression) : base(TokenKind.ExpressionStatement) { + Slots = 1; + this.AdjustWidth(expression); + _expression = expression; + } + internal ExpressionStatementSyntaxNode( + ExpressionSyntaxNode expression, + TokenDiagnostic[] diagnostics) : base(TokenKind.ExpressionStatement, diagnostics) + { Slots = 1; this.AdjustWidth(expression); _expression = expression; @@ -615,7 +929,12 @@ namespace Parser.Internal return new Parser.ExpressionStatementSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ExpressionStatementSyntaxNode(_expression, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -632,7 +951,15 @@ namespace Parser.Internal internal EmptyStatementSyntaxNode( SyntaxToken semicolon) : base(TokenKind.EmptyStatement) { + Slots = 1; + this.AdjustWidth(semicolon); + _semicolon = semicolon; + } + internal EmptyStatementSyntaxNode( + SyntaxToken semicolon, + TokenDiagnostic[] diagnostics) : base(TokenKind.EmptyStatement, diagnostics) + { Slots = 1; this.AdjustWidth(semicolon); _semicolon = semicolon; @@ -643,7 +970,12 @@ namespace Parser.Internal return new Parser.EmptyStatementSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new EmptyStatementSyntaxNode(_semicolon, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -658,7 +990,12 @@ namespace Parser.Internal internal EmptyExpressionSyntaxNode() : base(TokenKind.EmptyExpression) { + Slots = 0; + } + internal EmptyExpressionSyntaxNode( + TokenDiagnostic[] diagnostics) : base(TokenKind.EmptyExpression, diagnostics) + { Slots = 0; } @@ -667,7 +1004,12 @@ namespace Parser.Internal return new Parser.EmptyExpressionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new EmptyExpressionSyntaxNode(diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -685,7 +1027,18 @@ namespace Parser.Internal SyntaxToken operation, ExpressionSyntaxNode operand) : base(TokenKind.UnaryPrefixOperationExpression) { + Slots = 2; + this.AdjustWidth(operation); + _operation = operation; + this.AdjustWidth(operand); + _operand = operand; + } + internal UnaryPrefixOperationExpressionSyntaxNode( + SyntaxToken operation, + ExpressionSyntaxNode operand, + TokenDiagnostic[] diagnostics) : base(TokenKind.UnaryPrefixOperationExpression, diagnostics) + { Slots = 2; this.AdjustWidth(operation); _operation = operation; @@ -698,7 +1051,12 @@ namespace Parser.Internal return new Parser.UnaryPrefixOperationExpressionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new UnaryPrefixOperationExpressionSyntaxNode(_operation, _operand, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -716,7 +1074,15 @@ namespace Parser.Internal internal CompoundNameSyntaxNode( SyntaxList nodes) : base(TokenKind.CompoundName) { + Slots = 1; + this.AdjustWidth(nodes); + _nodes = nodes; + } + internal CompoundNameSyntaxNode( + SyntaxList nodes, + TokenDiagnostic[] diagnostics) : base(TokenKind.CompoundName, diagnostics) + { Slots = 1; this.AdjustWidth(nodes); _nodes = nodes; @@ -727,7 +1093,12 @@ namespace Parser.Internal return new Parser.CompoundNameSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new CompoundNameSyntaxNode(_nodes, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -746,7 +1117,18 @@ namespace Parser.Internal SyntaxToken atSign, CompoundNameSyntaxNode functionName) : base(TokenKind.NamedFunctionHandle) { + Slots = 2; + this.AdjustWidth(atSign); + _atSign = atSign; + this.AdjustWidth(functionName); + _functionName = functionName; + } + internal NamedFunctionHandleSyntaxNode( + SyntaxToken atSign, + CompoundNameSyntaxNode functionName, + TokenDiagnostic[] diagnostics) : base(TokenKind.NamedFunctionHandle, diagnostics) + { Slots = 2; this.AdjustWidth(atSign); _atSign = atSign; @@ -759,7 +1141,12 @@ namespace Parser.Internal return new Parser.NamedFunctionHandleSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new NamedFunctionHandleSyntaxNode(_atSign, _functionName, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -781,7 +1168,21 @@ namespace Parser.Internal FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body) : base(TokenKind.Lambda) { + Slots = 3; + this.AdjustWidth(atSign); + _atSign = atSign; + this.AdjustWidth(input); + _input = input; + this.AdjustWidth(body); + _body = body; + } + internal LambdaSyntaxNode( + SyntaxToken atSign, + FunctionInputDescriptionSyntaxNode input, + ExpressionSyntaxNode body, + TokenDiagnostic[] diagnostics) : base(TokenKind.Lambda, diagnostics) + { Slots = 3; this.AdjustWidth(atSign); _atSign = atSign; @@ -796,7 +1197,12 @@ namespace Parser.Internal return new Parser.LambdaSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new LambdaSyntaxNode(_atSign, _input, _body, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -819,7 +1225,21 @@ namespace Parser.Internal SyntaxToken operation, ExpressionSyntaxNode rhs) : base(TokenKind.BinaryOperation) { + Slots = 3; + this.AdjustWidth(lhs); + _lhs = lhs; + this.AdjustWidth(operation); + _operation = operation; + this.AdjustWidth(rhs); + _rhs = rhs; + } + internal BinaryOperationExpressionSyntaxNode( + ExpressionSyntaxNode lhs, + SyntaxToken operation, + ExpressionSyntaxNode rhs, + TokenDiagnostic[] diagnostics) : base(TokenKind.BinaryOperation, diagnostics) + { Slots = 3; this.AdjustWidth(lhs); _lhs = lhs; @@ -834,7 +1254,12 @@ namespace Parser.Internal return new Parser.BinaryOperationExpressionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new BinaryOperationExpressionSyntaxNode(_lhs, _operation, _rhs, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -853,7 +1278,15 @@ namespace Parser.Internal internal IdentifierNameSyntaxNode( SyntaxToken name) : base(TokenKind.IdentifierName) { + Slots = 1; + this.AdjustWidth(name); + _name = name; + } + internal IdentifierNameSyntaxNode( + SyntaxToken name, + TokenDiagnostic[] diagnostics) : base(TokenKind.IdentifierName, diagnostics) + { Slots = 1; this.AdjustWidth(name); _name = name; @@ -864,7 +1297,12 @@ namespace Parser.Internal return new Parser.IdentifierNameSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new IdentifierNameSyntaxNode(_name, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -881,7 +1319,15 @@ namespace Parser.Internal internal NumberLiteralSyntaxNode( SyntaxToken number) : base(TokenKind.NumberLiteralExpression) { + Slots = 1; + this.AdjustWidth(number); + _number = number; + } + internal NumberLiteralSyntaxNode( + SyntaxToken number, + TokenDiagnostic[] diagnostics) : base(TokenKind.NumberLiteralExpression, diagnostics) + { Slots = 1; this.AdjustWidth(number); _number = number; @@ -892,7 +1338,12 @@ namespace Parser.Internal return new Parser.NumberLiteralSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new NumberLiteralSyntaxNode(_number, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -909,7 +1360,15 @@ namespace Parser.Internal internal StringLiteralSyntaxNode( SyntaxToken stringToken) : base(TokenKind.StringLiteralExpression) { + Slots = 1; + this.AdjustWidth(stringToken); + _stringToken = stringToken; + } + internal StringLiteralSyntaxNode( + SyntaxToken stringToken, + TokenDiagnostic[] diagnostics) : base(TokenKind.StringLiteralExpression, diagnostics) + { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; @@ -920,7 +1379,12 @@ namespace Parser.Internal return new Parser.StringLiteralSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new StringLiteralSyntaxNode(_stringToken, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -937,7 +1401,15 @@ namespace Parser.Internal internal DoubleQuotedStringLiteralSyntaxNode( SyntaxToken stringToken) : base(TokenKind.DoubleQuotedStringLiteralExpression) { + Slots = 1; + this.AdjustWidth(stringToken); + _stringToken = stringToken; + } + internal DoubleQuotedStringLiteralSyntaxNode( + SyntaxToken stringToken, + TokenDiagnostic[] diagnostics) : base(TokenKind.DoubleQuotedStringLiteralExpression, diagnostics) + { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; @@ -948,7 +1420,12 @@ namespace Parser.Internal return new Parser.DoubleQuotedStringLiteralSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new DoubleQuotedStringLiteralSyntaxNode(_stringToken, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -965,7 +1442,15 @@ namespace Parser.Internal internal UnquotedStringLiteralSyntaxNode( SyntaxToken stringToken) : base(TokenKind.UnquotedStringLiteralExpression) { + Slots = 1; + this.AdjustWidth(stringToken); + _stringToken = stringToken; + } + internal UnquotedStringLiteralSyntaxNode( + SyntaxToken stringToken, + TokenDiagnostic[] diagnostics) : base(TokenKind.UnquotedStringLiteralExpression, diagnostics) + { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; @@ -976,7 +1461,12 @@ namespace Parser.Internal return new Parser.UnquotedStringLiteralSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new UnquotedStringLiteralSyntaxNode(_stringToken, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -997,7 +1487,21 @@ namespace Parser.Internal SyntaxList nodes, SyntaxToken closingSquareBracket) : base(TokenKind.ArrayLiteralExpression) { + Slots = 3; + this.AdjustWidth(openingSquareBracket); + _openingSquareBracket = openingSquareBracket; + this.AdjustWidth(nodes); + _nodes = nodes; + this.AdjustWidth(closingSquareBracket); + _closingSquareBracket = closingSquareBracket; + } + internal ArrayLiteralExpressionSyntaxNode( + SyntaxToken openingSquareBracket, + SyntaxList nodes, + SyntaxToken closingSquareBracket, + TokenDiagnostic[] diagnostics) : base(TokenKind.ArrayLiteralExpression, diagnostics) + { Slots = 3; this.AdjustWidth(openingSquareBracket); _openingSquareBracket = openingSquareBracket; @@ -1012,7 +1516,12 @@ namespace Parser.Internal return new Parser.ArrayLiteralExpressionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ArrayLiteralExpressionSyntaxNode(_openingSquareBracket, _nodes, _closingSquareBracket, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1035,7 +1544,21 @@ namespace Parser.Internal SyntaxList nodes, SyntaxToken closingBrace) : base(TokenKind.CellArrayLiteralExpression) { + Slots = 3; + this.AdjustWidth(openingBrace); + _openingBrace = openingBrace; + this.AdjustWidth(nodes); + _nodes = nodes; + this.AdjustWidth(closingBrace); + _closingBrace = closingBrace; + } + internal CellArrayLiteralExpressionSyntaxNode( + SyntaxToken openingBrace, + SyntaxList nodes, + SyntaxToken closingBrace, + TokenDiagnostic[] diagnostics) : base(TokenKind.CellArrayLiteralExpression, diagnostics) + { Slots = 3; this.AdjustWidth(openingBrace); _openingBrace = openingBrace; @@ -1050,7 +1573,12 @@ namespace Parser.Internal return new Parser.CellArrayLiteralExpressionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new CellArrayLiteralExpressionSyntaxNode(_openingBrace, _nodes, _closingBrace, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1073,7 +1601,21 @@ namespace Parser.Internal ExpressionSyntaxNode expression, SyntaxToken closingBracket) : base(TokenKind.ParenthesizedExpression) { + Slots = 3; + this.AdjustWidth(openingBracket); + _openingBracket = openingBracket; + this.AdjustWidth(expression); + _expression = expression; + this.AdjustWidth(closingBracket); + _closingBracket = closingBracket; + } + internal ParenthesizedExpressionSyntaxNode( + SyntaxToken openingBracket, + ExpressionSyntaxNode expression, + SyntaxToken closingBracket, + TokenDiagnostic[] diagnostics) : base(TokenKind.ParenthesizedExpression, diagnostics) + { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; @@ -1088,7 +1630,12 @@ namespace Parser.Internal return new Parser.ParenthesizedExpressionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ParenthesizedExpressionSyntaxNode(_openingBracket, _expression, _closingBracket, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1113,7 +1660,24 @@ namespace Parser.Internal SyntaxList nodes, SyntaxToken closingBrace) : base(TokenKind.CellArrayElementAccess) { + Slots = 4; + this.AdjustWidth(expression); + _expression = expression; + this.AdjustWidth(openingBrace); + _openingBrace = openingBrace; + this.AdjustWidth(nodes); + _nodes = nodes; + this.AdjustWidth(closingBrace); + _closingBrace = closingBrace; + } + internal CellArrayElementAccessExpressionSyntaxNode( + ExpressionSyntaxNode expression, + SyntaxToken openingBrace, + SyntaxList nodes, + SyntaxToken closingBrace, + TokenDiagnostic[] diagnostics) : base(TokenKind.CellArrayElementAccess, diagnostics) + { Slots = 4; this.AdjustWidth(expression); _expression = expression; @@ -1130,7 +1694,12 @@ namespace Parser.Internal return new Parser.CellArrayElementAccessExpressionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new CellArrayElementAccessExpressionSyntaxNode(_expression, _openingBrace, _nodes, _closingBrace, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1156,7 +1725,24 @@ namespace Parser.Internal SyntaxList nodes, SyntaxToken closingBracket) : base(TokenKind.FunctionCall) { + Slots = 4; + this.AdjustWidth(functionName); + _functionName = functionName; + this.AdjustWidth(openingBracket); + _openingBracket = openingBracket; + this.AdjustWidth(nodes); + _nodes = nodes; + this.AdjustWidth(closingBracket); + _closingBracket = closingBracket; + } + internal FunctionCallExpressionSyntaxNode( + ExpressionSyntaxNode functionName, + SyntaxToken openingBracket, + SyntaxList nodes, + SyntaxToken closingBracket, + TokenDiagnostic[] diagnostics) : base(TokenKind.FunctionCall, diagnostics) + { Slots = 4; this.AdjustWidth(functionName); _functionName = functionName; @@ -1173,7 +1759,12 @@ namespace Parser.Internal return new Parser.FunctionCallExpressionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new FunctionCallExpressionSyntaxNode(_functionName, _openingBracket, _nodes, _closingBracket, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1197,7 +1788,21 @@ namespace Parser.Internal SyntaxToken dot, SyntaxNode rightOperand) : base(TokenKind.MemberAccess) { + Slots = 3; + this.AdjustWidth(leftOperand); + _leftOperand = leftOperand; + this.AdjustWidth(dot); + _dot = dot; + this.AdjustWidth(rightOperand); + _rightOperand = rightOperand; + } + internal MemberAccessSyntaxNode( + SyntaxNode leftOperand, + SyntaxToken dot, + SyntaxNode rightOperand, + TokenDiagnostic[] diagnostics) : base(TokenKind.MemberAccess, diagnostics) + { Slots = 3; this.AdjustWidth(leftOperand); _leftOperand = leftOperand; @@ -1212,7 +1817,12 @@ namespace Parser.Internal return new Parser.MemberAccessSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new MemberAccessSyntaxNode(_leftOperand, _dot, _rightOperand, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1233,7 +1843,18 @@ namespace Parser.Internal ExpressionSyntaxNode operand, SyntaxToken operation) : base(TokenKind.UnaryPostfixOperationExpression) { + Slots = 2; + this.AdjustWidth(operand); + _operand = operand; + this.AdjustWidth(operation); + _operation = operation; + } + internal UnaryPostixOperationExpressionSyntaxNode( + ExpressionSyntaxNode operand, + SyntaxToken operation, + TokenDiagnostic[] diagnostics) : base(TokenKind.UnaryPostfixOperationExpression, diagnostics) + { Slots = 2; this.AdjustWidth(operand); _operand = operand; @@ -1246,7 +1867,12 @@ namespace Parser.Internal return new Parser.UnaryPostixOperationExpressionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new UnaryPostixOperationExpressionSyntaxNode(_operand, _operation, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1268,7 +1894,21 @@ namespace Parser.Internal ExpressionSyntaxNode expression, SyntaxToken closingBracket) : base(TokenKind.IndirectMemberAccess) { + Slots = 3; + this.AdjustWidth(openingBracket); + _openingBracket = openingBracket; + this.AdjustWidth(expression); + _expression = expression; + this.AdjustWidth(closingBracket); + _closingBracket = closingBracket; + } + internal IndirectMemberAccessSyntaxNode( + SyntaxToken openingBracket, + ExpressionSyntaxNode expression, + SyntaxToken closingBracket, + TokenDiagnostic[] diagnostics) : base(TokenKind.IndirectMemberAccess, diagnostics) + { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; @@ -1283,7 +1923,12 @@ namespace Parser.Internal return new Parser.IndirectMemberAccessSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new IndirectMemberAccessSyntaxNode(_openingBracket, _expression, _closingBracket, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1304,7 +1949,18 @@ namespace Parser.Internal IdentifierNameSyntaxNode commandName, SyntaxList arguments) : base(TokenKind.Command) { + Slots = 2; + this.AdjustWidth(commandName); + _commandName = commandName; + this.AdjustWidth(arguments); + _arguments = arguments; + } + internal CommandExpressionSyntaxNode( + IdentifierNameSyntaxNode commandName, + SyntaxList arguments, + TokenDiagnostic[] diagnostics) : base(TokenKind.Command, diagnostics) + { Slots = 2; this.AdjustWidth(commandName); _commandName = commandName; @@ -1317,7 +1973,12 @@ namespace Parser.Internal return new Parser.CommandExpressionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new CommandExpressionSyntaxNode(_commandName, _arguments, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1339,7 +2000,21 @@ namespace Parser.Internal SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments) : base(TokenKind.ClassInvokation) { + Slots = 3; + this.AdjustWidth(methodName); + _methodName = methodName; + this.AdjustWidth(atSign); + _atSign = atSign; + this.AdjustWidth(baseClassNameAndArguments); + _baseClassNameAndArguments = baseClassNameAndArguments; + } + internal BaseClassInvokationSyntaxNode( + ExpressionSyntaxNode methodName, + SyntaxToken atSign, + ExpressionSyntaxNode baseClassNameAndArguments, + TokenDiagnostic[] diagnostics) : base(TokenKind.ClassInvokation, diagnostics) + { Slots = 3; this.AdjustWidth(methodName); _methodName = methodName; @@ -1354,7 +2029,12 @@ namespace Parser.Internal return new Parser.BaseClassInvokationSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new BaseClassInvokationSyntaxNode(_methodName, _atSign, _baseClassNameAndArguments, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1375,7 +2055,18 @@ namespace Parser.Internal SyntaxToken assignmentSign, ExpressionSyntaxNode value) : base(TokenKind.AttributeAssignment) { + Slots = 2; + this.AdjustWidth(assignmentSign); + _assignmentSign = assignmentSign; + this.AdjustWidth(value); + _value = value; + } + internal AttributeAssignmentSyntaxNode( + SyntaxToken assignmentSign, + ExpressionSyntaxNode value, + TokenDiagnostic[] diagnostics) : base(TokenKind.AttributeAssignment, diagnostics) + { Slots = 2; this.AdjustWidth(assignmentSign); _assignmentSign = assignmentSign; @@ -1388,7 +2079,12 @@ namespace Parser.Internal return new Parser.AttributeAssignmentSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new AttributeAssignmentSyntaxNode(_assignmentSign, _value, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1402,13 +2098,24 @@ namespace Parser.Internal internal class AttributeSyntaxNode : SyntaxNode { internal readonly IdentifierNameSyntaxNode _name; - internal readonly AttributeAssignmentSyntaxNode _assignment; + internal readonly AttributeAssignmentSyntaxNode? _assignment; internal AttributeSyntaxNode( IdentifierNameSyntaxNode name, - AttributeAssignmentSyntaxNode assignment) : base(TokenKind.Attribute) + AttributeAssignmentSyntaxNode? assignment) : base(TokenKind.Attribute) { + Slots = 2; + this.AdjustWidth(name); + _name = name; + this.AdjustWidth(assignment); + _assignment = assignment; + } + internal AttributeSyntaxNode( + IdentifierNameSyntaxNode name, + AttributeAssignmentSyntaxNode? assignment, + TokenDiagnostic[] diagnostics) : base(TokenKind.Attribute, diagnostics) + { Slots = 2; this.AdjustWidth(name); _name = name; @@ -1421,7 +2128,12 @@ namespace Parser.Internal return new Parser.AttributeSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new AttributeSyntaxNode(_name, _assignment, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1443,7 +2155,21 @@ namespace Parser.Internal SyntaxList nodes, SyntaxToken closingBracket) : base(TokenKind.AttributeList) { + Slots = 3; + this.AdjustWidth(openingBracket); + _openingBracket = openingBracket; + this.AdjustWidth(nodes); + _nodes = nodes; + this.AdjustWidth(closingBracket); + _closingBracket = closingBracket; + } + internal AttributeListSyntaxNode( + SyntaxToken openingBracket, + SyntaxList nodes, + SyntaxToken closingBracket, + TokenDiagnostic[] diagnostics) : base(TokenKind.AttributeList, diagnostics) + { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; @@ -1458,7 +2184,12 @@ namespace Parser.Internal return new Parser.AttributeListSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new AttributeListSyntaxNode(_openingBracket, _nodes, _closingBracket, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1473,23 +2204,49 @@ namespace Parser.Internal internal class MethodDefinitionSyntaxNode : MethodDeclarationSyntaxNode { internal readonly SyntaxToken _functionKeyword; - internal readonly FunctionOutputDescriptionSyntaxNode _outputDescription; + internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription; internal readonly CompoundNameSyntaxNode _name; - internal readonly FunctionInputDescriptionSyntaxNode _inputDescription; + internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription; internal readonly SyntaxList _commas; internal readonly SyntaxList _body; - internal readonly SyntaxToken _endKeyword; + internal readonly EndKeywordSyntaxNode? _endKeyword; internal MethodDefinitionSyntaxNode( SyntaxToken functionKeyword, - FunctionOutputDescriptionSyntaxNode outputDescription, + FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, - FunctionInputDescriptionSyntaxNode inputDescription, + FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, - SyntaxToken endKeyword) : base(TokenKind.MethodDefinition) + EndKeywordSyntaxNode? endKeyword) : base(TokenKind.MethodDefinition) { + Slots = 7; + this.AdjustWidth(functionKeyword); + _functionKeyword = functionKeyword; + this.AdjustWidth(outputDescription); + _outputDescription = outputDescription; + this.AdjustWidth(name); + _name = name; + this.AdjustWidth(inputDescription); + _inputDescription = inputDescription; + this.AdjustWidth(commas); + _commas = commas; + this.AdjustWidth(body); + _body = body; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal MethodDefinitionSyntaxNode( + SyntaxToken functionKeyword, + FunctionOutputDescriptionSyntaxNode? outputDescription, + CompoundNameSyntaxNode name, + FunctionInputDescriptionSyntaxNode? inputDescription, + SyntaxList commas, + SyntaxList body, + EndKeywordSyntaxNode? endKeyword, + TokenDiagnostic[] diagnostics) : base(TokenKind.MethodDefinition, diagnostics) + { Slots = 7; this.AdjustWidth(functionKeyword); _functionKeyword = functionKeyword; @@ -1512,7 +2269,12 @@ namespace Parser.Internal return new Parser.MethodDefinitionSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new MethodDefinitionSyntaxNode(_functionKeyword, _outputDescription, _name, _inputDescription, _commas, _body, _endKeyword, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1530,16 +2292,30 @@ namespace Parser.Internal internal class AbstractMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode { - internal readonly FunctionOutputDescriptionSyntaxNode _outputDescription; + internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription; internal readonly CompoundNameSyntaxNode _name; - internal readonly FunctionInputDescriptionSyntaxNode _inputDescription; + internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription; internal AbstractMethodDeclarationSyntaxNode( - FunctionOutputDescriptionSyntaxNode outputDescription, + FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, - FunctionInputDescriptionSyntaxNode inputDescription) : base(TokenKind.AbstractMethodDeclaration) + FunctionInputDescriptionSyntaxNode? inputDescription) : base(TokenKind.AbstractMethodDeclaration) { + Slots = 3; + this.AdjustWidth(outputDescription); + _outputDescription = outputDescription; + this.AdjustWidth(name); + _name = name; + this.AdjustWidth(inputDescription); + _inputDescription = inputDescription; + } + internal AbstractMethodDeclarationSyntaxNode( + FunctionOutputDescriptionSyntaxNode? outputDescription, + CompoundNameSyntaxNode name, + FunctionInputDescriptionSyntaxNode? inputDescription, + TokenDiagnostic[] diagnostics) : base(TokenKind.AbstractMethodDeclaration, diagnostics) + { Slots = 3; this.AdjustWidth(outputDescription); _outputDescription = outputDescription; @@ -1554,7 +2330,12 @@ namespace Parser.Internal return new Parser.AbstractMethodDeclarationSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new AbstractMethodDeclarationSyntaxNode(_outputDescription, _name, _inputDescription, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1569,17 +2350,34 @@ namespace Parser.Internal internal class MethodsListSyntaxNode : SyntaxNode { internal readonly SyntaxToken _methodsKeyword; - internal readonly AttributeListSyntaxNode _attributes; + internal readonly AttributeListSyntaxNode? _attributes; internal readonly SyntaxList _methods; internal readonly SyntaxToken _endKeyword; internal MethodsListSyntaxNode( SyntaxToken methodsKeyword, - AttributeListSyntaxNode attributes, + AttributeListSyntaxNode? attributes, SyntaxList methods, SyntaxToken endKeyword) : base(TokenKind.MethodsList) { + Slots = 4; + this.AdjustWidth(methodsKeyword); + _methodsKeyword = methodsKeyword; + this.AdjustWidth(attributes); + _attributes = attributes; + this.AdjustWidth(methods); + _methods = methods; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal MethodsListSyntaxNode( + SyntaxToken methodsKeyword, + AttributeListSyntaxNode? attributes, + SyntaxList methods, + SyntaxToken endKeyword, + TokenDiagnostic[] diagnostics) : base(TokenKind.MethodsList, diagnostics) + { Slots = 4; this.AdjustWidth(methodsKeyword); _methodsKeyword = methodsKeyword; @@ -1596,7 +2394,12 @@ namespace Parser.Internal return new Parser.MethodsListSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new MethodsListSyntaxNode(_methodsKeyword, _attributes, _methods, _endKeyword, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1612,17 +2415,34 @@ namespace Parser.Internal internal class PropertiesListSyntaxNode : SyntaxNode { internal readonly SyntaxToken _propertiesKeyword; - internal readonly AttributeListSyntaxNode _attributes; + internal readonly AttributeListSyntaxNode? _attributes; internal readonly SyntaxList _properties; internal readonly SyntaxToken _endKeyword; internal PropertiesListSyntaxNode( SyntaxToken propertiesKeyword, - AttributeListSyntaxNode attributes, + AttributeListSyntaxNode? attributes, SyntaxList properties, SyntaxToken endKeyword) : base(TokenKind.PropertiesList) { + Slots = 4; + this.AdjustWidth(propertiesKeyword); + _propertiesKeyword = propertiesKeyword; + this.AdjustWidth(attributes); + _attributes = attributes; + this.AdjustWidth(properties); + _properties = properties; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal PropertiesListSyntaxNode( + SyntaxToken propertiesKeyword, + AttributeListSyntaxNode? attributes, + SyntaxList properties, + SyntaxToken endKeyword, + TokenDiagnostic[] diagnostics) : base(TokenKind.PropertiesList, diagnostics) + { Slots = 4; this.AdjustWidth(propertiesKeyword); _propertiesKeyword = propertiesKeyword; @@ -1639,7 +2459,12 @@ namespace Parser.Internal return new Parser.PropertiesListSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new PropertiesListSyntaxNode(_propertiesKeyword, _attributes, _properties, _endKeyword, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1661,7 +2486,18 @@ namespace Parser.Internal SyntaxToken lessSign, SyntaxList baseClasses) : base(TokenKind.BaseClassList) { + Slots = 2; + this.AdjustWidth(lessSign); + _lessSign = lessSign; + this.AdjustWidth(baseClasses); + _baseClasses = baseClasses; + } + internal BaseClassListSyntaxNode( + SyntaxToken lessSign, + SyntaxList baseClasses, + TokenDiagnostic[] diagnostics) : base(TokenKind.BaseClassList, diagnostics) + { Slots = 2; this.AdjustWidth(lessSign); _lessSign = lessSign; @@ -1674,7 +2510,12 @@ namespace Parser.Internal return new Parser.BaseClassListSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new BaseClassListSyntaxNode(_lessSign, _baseClasses, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1688,21 +2529,44 @@ namespace Parser.Internal internal class ClassDeclarationSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _classdefKeyword; - internal readonly AttributeListSyntaxNode _attributes; + internal readonly AttributeListSyntaxNode? _attributes; internal readonly IdentifierNameSyntaxNode _className; - internal readonly BaseClassListSyntaxNode _baseClassList; + internal readonly BaseClassListSyntaxNode? _baseClassList; internal readonly SyntaxList _nodes; internal readonly SyntaxToken _endKeyword; internal ClassDeclarationSyntaxNode( SyntaxToken classdefKeyword, - AttributeListSyntaxNode attributes, + AttributeListSyntaxNode? attributes, IdentifierNameSyntaxNode className, - BaseClassListSyntaxNode baseClassList, + BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword) : base(TokenKind.ClassDeclaration) { + Slots = 6; + this.AdjustWidth(classdefKeyword); + _classdefKeyword = classdefKeyword; + this.AdjustWidth(attributes); + _attributes = attributes; + this.AdjustWidth(className); + _className = className; + this.AdjustWidth(baseClassList); + _baseClassList = baseClassList; + this.AdjustWidth(nodes); + _nodes = nodes; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal ClassDeclarationSyntaxNode( + SyntaxToken classdefKeyword, + AttributeListSyntaxNode? attributes, + IdentifierNameSyntaxNode className, + BaseClassListSyntaxNode? baseClassList, + SyntaxList nodes, + SyntaxToken endKeyword, + TokenDiagnostic[] diagnostics) : base(TokenKind.ClassDeclaration, diagnostics) + { Slots = 6; this.AdjustWidth(classdefKeyword); _classdefKeyword = classdefKeyword; @@ -1723,7 +2587,12 @@ namespace Parser.Internal return new Parser.ClassDeclarationSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ClassDeclarationSyntaxNode(_classdefKeyword, _attributes, _className, _baseClassList, _nodes, _endKeyword, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1749,7 +2618,21 @@ namespace Parser.Internal SyntaxList values, SyntaxToken closingBracket) : base(TokenKind.EnumerationItemValue) { + Slots = 3; + this.AdjustWidth(openingBracket); + _openingBracket = openingBracket; + this.AdjustWidth(values); + _values = values; + this.AdjustWidth(closingBracket); + _closingBracket = closingBracket; + } + internal EnumerationItemValueSyntaxNode( + SyntaxToken openingBracket, + SyntaxList values, + SyntaxToken closingBracket, + TokenDiagnostic[] diagnostics) : base(TokenKind.EnumerationItemValue, diagnostics) + { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; @@ -1764,7 +2647,12 @@ namespace Parser.Internal return new Parser.EnumerationItemValueSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new EnumerationItemValueSyntaxNode(_openingBracket, _values, _closingBracket, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1779,15 +2667,29 @@ namespace Parser.Internal internal class EnumerationItemSyntaxNode : SyntaxNode { internal readonly IdentifierNameSyntaxNode _name; - internal readonly EnumerationItemValueSyntaxNode _values; + internal readonly EnumerationItemValueSyntaxNode? _values; internal readonly SyntaxList _commas; internal EnumerationItemSyntaxNode( IdentifierNameSyntaxNode name, - EnumerationItemValueSyntaxNode values, + EnumerationItemValueSyntaxNode? values, SyntaxList commas) : base(TokenKind.EnumerationItem) { + Slots = 3; + this.AdjustWidth(name); + _name = name; + this.AdjustWidth(values); + _values = values; + this.AdjustWidth(commas); + _commas = commas; + } + internal EnumerationItemSyntaxNode( + IdentifierNameSyntaxNode name, + EnumerationItemValueSyntaxNode? values, + SyntaxList commas, + TokenDiagnostic[] diagnostics) : base(TokenKind.EnumerationItem, diagnostics) + { Slots = 3; this.AdjustWidth(name); _name = name; @@ -1802,7 +2704,12 @@ namespace Parser.Internal return new Parser.EnumerationItemSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new EnumerationItemSyntaxNode(_name, _values, _commas, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1817,17 +2724,34 @@ namespace Parser.Internal internal class EnumerationListSyntaxNode : SyntaxNode { internal readonly SyntaxToken _enumerationKeyword; - internal readonly AttributeListSyntaxNode _attributes; + internal readonly AttributeListSyntaxNode? _attributes; internal readonly SyntaxList _items; internal readonly SyntaxToken _endKeyword; internal EnumerationListSyntaxNode( SyntaxToken enumerationKeyword, - AttributeListSyntaxNode attributes, + AttributeListSyntaxNode? attributes, SyntaxList items, SyntaxToken endKeyword) : base(TokenKind.EnumerationList) { + Slots = 4; + this.AdjustWidth(enumerationKeyword); + _enumerationKeyword = enumerationKeyword; + this.AdjustWidth(attributes); + _attributes = attributes; + this.AdjustWidth(items); + _items = items; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal EnumerationListSyntaxNode( + SyntaxToken enumerationKeyword, + AttributeListSyntaxNode? attributes, + SyntaxList items, + SyntaxToken endKeyword, + TokenDiagnostic[] diagnostics) : base(TokenKind.EnumerationList, diagnostics) + { Slots = 4; this.AdjustWidth(enumerationKeyword); _enumerationKeyword = enumerationKeyword; @@ -1844,7 +2768,12 @@ namespace Parser.Internal return new Parser.EnumerationListSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new EnumerationListSyntaxNode(_enumerationKeyword, _attributes, _items, _endKeyword, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1860,17 +2789,34 @@ namespace Parser.Internal internal class EventsListSyntaxNode : SyntaxNode { internal readonly SyntaxToken _eventsKeyword; - internal readonly AttributeListSyntaxNode _attributes; + internal readonly AttributeListSyntaxNode? _attributes; internal readonly SyntaxList _events; internal readonly SyntaxToken _endKeyword; internal EventsListSyntaxNode( SyntaxToken eventsKeyword, - AttributeListSyntaxNode attributes, + AttributeListSyntaxNode? attributes, SyntaxList events, SyntaxToken endKeyword) : base(TokenKind.EventsList) { + Slots = 4; + this.AdjustWidth(eventsKeyword); + _eventsKeyword = eventsKeyword; + this.AdjustWidth(attributes); + _attributes = attributes; + this.AdjustWidth(events); + _events = events; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal EventsListSyntaxNode( + SyntaxToken eventsKeyword, + AttributeListSyntaxNode? attributes, + SyntaxList events, + SyntaxToken endKeyword, + TokenDiagnostic[] diagnostics) : base(TokenKind.EventsList, diagnostics) + { Slots = 4; this.AdjustWidth(eventsKeyword); _eventsKeyword = eventsKeyword; @@ -1887,7 +2833,12 @@ namespace Parser.Internal return new Parser.EventsListSyntaxNode(parent, this, position); } - public override GreenNode GetSlot(int i) + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new EventsListSyntaxNode(_eventsKeyword, _attributes, _events, _endKeyword, diagnostics); + } + + public override GreenNode? GetSlot(int i) { switch (i) { @@ -1899,4 +2850,45 @@ namespace Parser.Internal } } } + + internal class EndKeywordSyntaxNode : SyntaxNode + { + internal readonly SyntaxToken _endKeyword; + + internal EndKeywordSyntaxNode( + SyntaxToken endKeyword) : base(TokenKind.EndKeyword) + { + Slots = 1; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + + internal EndKeywordSyntaxNode( + SyntaxToken endKeyword, + TokenDiagnostic[] diagnostics) : base(TokenKind.EndKeyword, diagnostics) + { + Slots = 1; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) + { + return new Parser.EndKeywordSyntaxNode(parent, this, position); + } + + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new EndKeywordSyntaxNode(_endKeyword, diagnostics); + } + + public override GreenNode? GetSlot(int i) + { + switch (i) + { + case 0: return _endKeyword; + default: return null; + } + } + } } diff --git a/Parser/Internal/SyntaxNode.cs b/Parser/Internal/SyntaxNode.cs index 9ddf794..5970df3 100644 --- a/Parser/Internal/SyntaxNode.cs +++ b/Parser/Internal/SyntaxNode.cs @@ -10,6 +10,11 @@ namespace Parser.Internal { } + protected SyntaxNode(TokenKind kind, TokenDiagnostic[] diagnostics) + : base(kind, diagnostics) + { + } + public IEnumerable DescendantTokens => CalculateChildTokens(); private IEnumerable CalculateChildTokens() @@ -57,13 +62,21 @@ namespace Parser.Internal protected StatementSyntaxNode(TokenKind kind) : base(kind) { } + + protected StatementSyntaxNode(TokenKind kind, TokenDiagnostic[] diagnostics) : base(kind, diagnostics) + { + } } - + internal abstract class ExpressionSyntaxNode : SyntaxNode { protected ExpressionSyntaxNode(TokenKind kind) : base(kind) { } + + protected ExpressionSyntaxNode(TokenKind kind, TokenDiagnostic[] diagnostics) : base(kind, diagnostics) + { + } } internal abstract class FunctionHandleSyntaxNode : ExpressionSyntaxNode @@ -71,6 +84,10 @@ namespace Parser.Internal protected FunctionHandleSyntaxNode(TokenKind kind) : base(kind) { } + + protected FunctionHandleSyntaxNode(TokenKind kind, TokenDiagnostic[] diagnostics) : base(kind, diagnostics) + { + } } internal abstract class MethodDeclarationSyntaxNode : StatementSyntaxNode @@ -78,5 +95,47 @@ namespace Parser.Internal protected MethodDeclarationSyntaxNode(TokenKind kind) : base(kind) { } + + protected MethodDeclarationSyntaxNode(TokenKind kind, TokenDiagnostic[] diagnostics) : base(kind, diagnostics) + { + } + } + + internal class RootSyntaxNode : SyntaxNode + { + internal readonly FileSyntaxNode _file; + + public RootSyntaxNode(FileSyntaxNode file) : base(TokenKind.Root) + { + Slots = 1; + this.AdjustWidth(file); + _file = file; + } + + public RootSyntaxNode(FileSyntaxNode file, TokenDiagnostic[] diagnostics) : base(TokenKind.Root, diagnostics) + { + Slots = 1; + this.AdjustWidth(file); + _file = file; + } + + public override GreenNode? GetSlot(int i) + { + switch (i) + { + case 0: return _file; + default: return null; + } + } + + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new RootSyntaxNode(this._file, diagnostics); + } + + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) + { + return new Parser.RootSyntaxNode(this, position); + } } } diff --git a/Parser/Internal/SyntaxToken.cs b/Parser/Internal/SyntaxToken.cs index b230044..4c5ff63 100644 --- a/Parser/Internal/SyntaxToken.cs +++ b/Parser/Internal/SyntaxToken.cs @@ -7,12 +7,12 @@ namespace Parser.Internal { internal abstract class SyntaxToken : GreenNode { - public TextSpan Span { get; } + internal static IReadOnlyList s_EmptySyntaxTriviaList = new List(); internal class SyntaxTokenWithTrivia : SyntaxToken { private readonly string _text; - + public SyntaxTokenWithTrivia( TokenKind kind, string text, @@ -36,6 +36,31 @@ namespace Parser.Internal _fullWidth = (leadingTrivia?.Sum(t => t.FullWidth) ?? 0) + (_text?.Length ?? 0) + (trailingTrivia?.Sum(t => t.FullWidth) ?? 0); } + public SyntaxTokenWithTrivia( + TokenKind kind, + string text, + IReadOnlyList leadingTrivia, + IReadOnlyList trailingTrivia, + TokenDiagnostic[] diagnostics) : base(kind, diagnostics) + { + _text = text; + LeadingTriviaCore = leadingTrivia; + TrailingTriviaCore = trailingTrivia; + _fullWidth = (leadingTrivia?.Sum(t => t.FullWidth) ?? 0) + (text?.Length ?? 0) + (trailingTrivia?.Sum(t => t.FullWidth) ?? 0); + } + + public SyntaxTokenWithTrivia( + TokenKind kind, + IReadOnlyList leadingTrivia, + IReadOnlyList trailingTrivia, + TokenDiagnostic[] diagnostics) : base(kind, diagnostics) + { + _text = base.Text; + LeadingTriviaCore = leadingTrivia; + TrailingTriviaCore = trailingTrivia; + _fullWidth = (leadingTrivia?.Sum(t => t.FullWidth) ?? 0) + (_text?.Length ?? 0) + (trailingTrivia?.Sum(t => t.FullWidth) ?? 0); + } + public override void WriteTokenTo(TextWriter writer, bool leading, bool trailing) { if (leading) @@ -55,6 +80,11 @@ namespace Parser.Internal } } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new SyntaxTokenWithTrivia(Kind, _text, LeadingTrivia, TrailingTrivia, diagnostics); + } + public override IReadOnlyList LeadingTriviaCore { get; } public override IReadOnlyList TrailingTriviaCore { get; } @@ -75,10 +105,27 @@ namespace Parser.Internal _fullWidth = text?.Length ?? 0; } + public SyntaxTokenWithValue( + TokenKind kind, + string text, + T value, + TokenDiagnostic[] diagnostics) : base(kind, diagnostics) + { + _text = text; + _value = value; + _fullWidth = text?.Length ?? 0; + } + public override void WriteTokenTo(TextWriter writer, bool leading, bool trailing) { writer.Write(_text); } + + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new SyntaxTokenWithValue(Kind, _text, _value, diagnostics); + } + public T Value => _value; } @@ -96,10 +143,23 @@ namespace Parser.Internal _fullWidth = (leadingTrivia?.Sum(t => t.FullWidth) ?? 0) + (text?.Length ?? 0) + (trailingTrivia?.Sum(t => t.FullWidth) ?? 0); } + public SyntaxTokenWithValueAndTrivia( + TokenKind kind, + string text, + T value, + IReadOnlyList leadingTrivia, + IReadOnlyList trailingTrivia, + TokenDiagnostic[] diagnostics) : base(kind, text, value, diagnostics) + { + LeadingTriviaCore = leadingTrivia; + TrailingTriviaCore = trailingTrivia; + _fullWidth = (leadingTrivia?.Sum(t => t.FullWidth) ?? 0) + (text?.Length ?? 0) + (trailingTrivia?.Sum(t => t.FullWidth) ?? 0); + } + public override IReadOnlyList LeadingTriviaCore { get; } public override IReadOnlyList TrailingTriviaCore { get; } - + public override void WriteTokenTo(TextWriter writer, bool leading, bool trailing) { if (leading) @@ -118,6 +178,11 @@ namespace Parser.Internal } } } + + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new SyntaxTokenWithValueAndTrivia(Kind, _text, Value, LeadingTrivia, TrailingTrivia, diagnostics); + } } internal class SyntaxIdentifier : SyntaxToken @@ -129,9 +194,21 @@ namespace Parser.Internal writer.Write(_text); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new SyntaxIdentifier(_text, diagnostics); + } + public SyntaxIdentifier( - string text - ) : base(TokenKind.IdentifierToken) + string text) : base(TokenKind.IdentifierToken) + { + _text = text; + _fullWidth = text?.Length ?? 0; + } + + public SyntaxIdentifier( + string text, + TokenDiagnostic[] diagnostics) : base(TokenKind.IdentifierToken, diagnostics) { _text = text; _fullWidth = text?.Length ?? 0; @@ -142,7 +219,7 @@ namespace Parser.Internal { private readonly IReadOnlyList _leadingTrivia; private readonly IReadOnlyList _trailingTrivia; - + public override IReadOnlyList LeadingTriviaCore => _leadingTrivia; public override IReadOnlyList TrailingTriviaCore => _trailingTrivia; @@ -157,6 +234,17 @@ namespace Parser.Internal _fullWidth = (leadingTrivia?.Sum(t => t.FullWidth) ?? 0) + (text?.Length ?? 0) + (trailingTrivia?.Sum(t => t.FullWidth) ?? 0); } + public SyntaxIdentifierWithTrivia( + string text, + IReadOnlyList leadingTrivia, + IReadOnlyList trailingTrivia, + TokenDiagnostic[] diagnostics) : base(text, diagnostics) + { + _leadingTrivia = leadingTrivia; + _trailingTrivia = trailingTrivia; + _fullWidth = (leadingTrivia?.Sum(t => t.FullWidth) ?? 0) + (text?.Length ?? 0) + (trailingTrivia?.Sum(t => t.FullWidth) ?? 0); + } + public override void WriteTokenTo(TextWriter writer, bool leading, bool trailing) { if (leading) @@ -178,6 +266,11 @@ namespace Parser.Internal public override bool IsToken => true; public override bool IsNode => false; + + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new SyntaxIdentifierWithTrivia(Text, _leadingTrivia, _trailingTrivia, diagnostics); + } } internal class MissingTokenWithTrivia : SyntaxTokenWithTrivia @@ -191,19 +284,39 @@ namespace Parser.Internal _isMissing = true; } + public MissingTokenWithTrivia( + TokenKind kind, + IReadOnlyList leadingTrivia, + IReadOnlyList trailingTrivia, + TokenDiagnostic[] diagnostics) : base(kind, leadingTrivia, trailingTrivia, diagnostics) + { + _isMissing = true; + } + public override string Text => ""; + + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new MissingTokenWithTrivia(Kind, LeadingTrivia, TrailingTrivia, diagnostics); + } } protected SyntaxToken(TokenKind kind) : base(kind) { } - + + protected SyntaxToken(TokenKind kind, TokenDiagnostic[] diagnostics) : base(kind, diagnostics) + { + } + + internal static SyntaxToken NoneToken => new MissingTokenWithTrivia(TokenKind.None, s_EmptySyntaxTriviaList, s_EmptySyntaxTriviaList); + public virtual int Width => Text.Length; - public override IReadOnlyList LeadingTriviaCore => new List(); - public override IReadOnlyList TrailingTriviaCore => new List(); + public override IReadOnlyList LeadingTriviaCore => s_EmptySyntaxTriviaList; + public override IReadOnlyList TrailingTriviaCore => s_EmptySyntaxTriviaList; - public override GreenNode GetSlot(int i) + public override GreenNode? GetSlot(int i) { throw new System.InvalidOperationException(); } diff --git a/Parser/Internal/SyntaxTrivia.cs b/Parser/Internal/SyntaxTrivia.cs index 3d74c34..277bc5a 100644 --- a/Parser/Internal/SyntaxTrivia.cs +++ b/Parser/Internal/SyntaxTrivia.cs @@ -14,10 +14,15 @@ namespace Parser.Internal _text = text; } + public SyntaxTrivia(TokenKind kind, string text, TokenDiagnostic[] diagnostics) : base(kind, text.Length, diagnostics) + { + _text = text; + } + public override string Text => _text; public int Width => _text.Length; - public override GreenNode GetSlot(int i) + public override GreenNode? GetSlot(int i) { throw new System.NotImplementedException(); } @@ -35,6 +40,11 @@ namespace Parser.Internal writer.Write(_text); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new SyntaxTrivia(Kind, _text, diagnostics); + } + public override IReadOnlyList LeadingTriviaCore => new List(); public override IReadOnlyList TrailingTriviaCore => new List(); } diff --git a/Parser/Internal/TokenDiagnostic.cs b/Parser/Internal/TokenDiagnostic.cs new file mode 100644 index 0000000..b3dece9 --- /dev/null +++ b/Parser/Internal/TokenDiagnostic.cs @@ -0,0 +1,24 @@ +namespace Parser.Internal +{ + public class TokenDiagnostic + { + protected TokenDiagnostic() + { + } + + public static TokenDiagnostic MissingToken(TokenKind kind) + { + return new MissingTokenDiagnostic(kind); + } + } + + public class MissingTokenDiagnostic : TokenDiagnostic + { + internal MissingTokenDiagnostic(TokenKind kind) + { + Kind = kind; + } + + public TokenKind Kind { get; } + } +} diff --git a/Parser/Internal/TokenFactory.cs b/Parser/Internal/TokenFactory.cs index 221d734..1281663 100644 --- a/Parser/Internal/TokenFactory.cs +++ b/Parser/Internal/TokenFactory.cs @@ -51,10 +51,10 @@ namespace Parser.Internal public static SyntaxToken CreateMissing( TokenKind kind, - IReadOnlyList leadingTrivia, - IReadOnlyList trailingTrivia) + IReadOnlyList? leadingTrivia, + IReadOnlyList? trailingTrivia) { - return new SyntaxToken.MissingTokenWithTrivia(kind, leadingTrivia, trailingTrivia); + return new SyntaxToken.MissingTokenWithTrivia(kind, leadingTrivia ?? SyntaxToken.s_EmptySyntaxTriviaList, trailingTrivia ?? SyntaxToken.s_EmptySyntaxTriviaList); } } } \ No newline at end of file diff --git a/Parser/MParser.cs b/Parser/MParser.cs index 8a3d7a1..e47a1a8 100644 --- a/Parser/MParser.cs +++ b/Parser/MParser.cs @@ -20,23 +20,24 @@ namespace Parser var lexerDiagnostics = lexer.Diagnostics; var tokens = lexer.ParseAll(); var parser = new Internal.MParserGreen(tokens, new Internal.SyntaxFactory()); - var green = parser.ParseFile(); + var green = parser.ParseRoot(); var parserDiagnostics = parser.Diagnostics; var totalDiagnostics = new DiagnosticsBag(lexerDiagnostics.Concat(parserDiagnostics)); - var root = new FileSyntaxNode(null, green, 0); + var root = new RootSyntaxNode(green, 0); return new SyntaxTree(root, totalDiagnostics); } } public class SyntaxTree { - public SyntaxTree(FileSyntaxNode root, DiagnosticsBag diagnostics) + public SyntaxTree(RootSyntaxNode nullRoot, DiagnosticsBag diagnostics) { - Root = root ?? throw new ArgumentNullException(nameof(root)); + NullRoot = nullRoot ?? throw new ArgumentNullException(nameof(nullRoot)); Diagnostics = diagnostics ?? throw new ArgumentNullException(nameof(diagnostics)); } - public FileSyntaxNode Root { get; } + public RootSyntaxNode NullRoot { get; } + public FileSyntaxNode Root => NullRoot.File; public DiagnosticsBag Diagnostics { get; } } diff --git a/Parser/MissingTokenSyntaxDiagnostic.cs b/Parser/MissingTokenSyntaxDiagnostic.cs new file mode 100644 index 0000000..bf3c5f9 --- /dev/null +++ b/Parser/MissingTokenSyntaxDiagnostic.cs @@ -0,0 +1,13 @@ +namespace Parser +{ + public class MissingTokenSyntaxDiagnostic : SyntaxDiagnostic + { + public TokenKind Kind { get; } + + public MissingTokenSyntaxDiagnostic(int position, TokenKind tokenKind) + : base(position) + { + Kind = tokenKind; + } + } +} \ No newline at end of file diff --git a/Parser/Parser.csproj b/Parser/Parser.csproj index 2e5ff7c..be517b0 100644 --- a/Parser/Parser.csproj +++ b/Parser/Parser.csproj @@ -1,6 +1,8 @@  - netstandard2.0 + netcoreapp3.0 + 8.0 + enable diff --git a/Parser/Position.cs b/Parser/Position.cs index 56a71a5..e4ec6fe 100644 --- a/Parser/Position.cs +++ b/Parser/Position.cs @@ -2,7 +2,7 @@ { public struct Position { - public string FileName { get; set; } + public string? FileName { get; set; } public int Line { get; set; } public int Column { get; set; } public int Offset { get; set; } diff --git a/Parser/SyntaxDiagnostic.cs b/Parser/SyntaxDiagnostic.cs new file mode 100644 index 0000000..d0505e7 --- /dev/null +++ b/Parser/SyntaxDiagnostic.cs @@ -0,0 +1,23 @@ +namespace Parser +{ + public class SyntaxDiagnostic + { + public int Position { get; } + + public static SyntaxDiagnostic From(Internal.TokenDiagnostic diagnostic, int Position) + { + switch (diagnostic) + { + case Internal.MissingTokenDiagnostic missingToken: + return new MissingTokenSyntaxDiagnostic(Position, missingToken.Kind); + } + + throw new System.ArgumentOutOfRangeException(nameof(diagnostic)); + } + + protected SyntaxDiagnostic(int position) + { + Position = position; + } + } +} \ No newline at end of file diff --git a/Parser/SyntaxNode.Generated.cs b/Parser/SyntaxNode.Generated.cs index a621d93..d3f5bec 100644 --- a/Parser/SyntaxNode.Generated.cs +++ b/Parser/SyntaxNode.Generated.cs @@ -1,8 +1,9 @@ +#nullable enable namespace Parser { public class FileSyntaxNode : SyntaxNode { - private SyntaxNode _statementList; + private SyntaxNode? _statementList; internal FileSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -17,19 +18,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._statementList, 0); + var red = this.GetRed(ref this._statementList!, 0); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("statementList cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _statementList, 0); + case 0: return GetRed(ref _statementList!, 0); default: return null; } } @@ -43,10 +44,11 @@ namespace Parser public class FunctionDeclarationSyntaxNode : StatementSyntaxNode { - private SyntaxNode _outputDescription; - private SyntaxNode _inputDescription; - private SyntaxNode _commas; - private SyntaxNode _body; + private SyntaxNode? _outputDescription; + private SyntaxNode? _inputDescription; + private SyntaxNode? _commas; + private SyntaxNode? _body; + private SyntaxNode? _endKeyword; internal FunctionDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -62,12 +64,7 @@ namespace Parser get { return new SyntaxToken(this, ((Parser.Internal.FunctionDeclarationSyntaxNode)_green)._name, this.GetChildPosition(2)); } } - public SyntaxToken EndKeyword - { - get { return new SyntaxToken(this, ((Parser.Internal.FunctionDeclarationSyntaxNode)_green)._endKeyword, this.GetChildPosition(6)); } - } - - public FunctionOutputDescriptionSyntaxNode OutputDescription + public FunctionOutputDescriptionSyntaxNode? OutputDescription { get { @@ -79,7 +76,7 @@ namespace Parser } } - public FunctionInputDescriptionSyntaxNode InputDescription + public FunctionInputDescriptionSyntaxNode? InputDescription { get { @@ -95,11 +92,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._commas, 4); + var red = this.GetRed(ref this._commas!, 4); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("commas cannot be null"); } } @@ -107,22 +104,35 @@ namespace Parser { get { - var red = this.GetRed(ref this._body, 5); + var red = this.GetRed(ref this._body!, 5); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("body cannot be null"); } } - internal override SyntaxNode GetNode(int i) + public EndKeywordSyntaxNode? EndKeyword + { + get + { + var red = this.GetRed(ref this._endKeyword, 6); + if (red != null) + return (EndKeywordSyntaxNode)red; + + return default(EndKeywordSyntaxNode); + } + } + + internal override SyntaxNode? GetNode(int i) { switch (i) { case 1: return GetRed(ref _outputDescription, 1); case 3: return GetRed(ref _inputDescription, 3); - case 4: return GetRed(ref _commas, 4); - case 5: return GetRed(ref _body, 5); + case 4: return GetRed(ref _commas!, 4); + case 5: return GetRed(ref _body!, 5); + case 6: return GetRed(ref _endKeyword, 6); default: return null; } } @@ -136,7 +146,7 @@ namespace Parser public class FunctionOutputDescriptionSyntaxNode : SyntaxNode { - private SyntaxNode _outputList; + private SyntaxNode? _outputList; internal FunctionOutputDescriptionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -151,19 +161,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._outputList, 0); + var red = this.GetRed(ref this._outputList!, 0); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("outputList cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _outputList, 0); + case 0: return GetRed(ref _outputList!, 0); default: return null; } } @@ -177,7 +187,7 @@ namespace Parser public class FunctionInputDescriptionSyntaxNode : SyntaxNode { - private SyntaxNode _parameterList; + private SyntaxNode? _parameterList; internal FunctionInputDescriptionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -197,19 +207,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._parameterList, 1); + var red = this.GetRed(ref this._parameterList!, 1); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("parameterList cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _parameterList, 1); + case 1: return GetRed(ref _parameterList!, 1); default: return null; } } @@ -223,9 +233,9 @@ namespace Parser public class SwitchStatementSyntaxNode : StatementSyntaxNode { - private SyntaxNode _switchExpression; - private SyntaxNode _optionalCommas; - private SyntaxNode _cases; + private SyntaxNode? _switchExpression; + private SyntaxNode? _optionalCommas; + private SyntaxNode? _cases; internal SwitchStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -245,11 +255,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._switchExpression, 1); + var red = this.GetRed(ref this._switchExpression!, 1); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("switchExpression cannot be null"); } } @@ -257,11 +267,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._optionalCommas, 2); + var red = this.GetRed(ref this._optionalCommas!, 2); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("optionalCommas cannot be null"); } } @@ -269,21 +279,21 @@ namespace Parser { get { - var red = this.GetRed(ref this._cases, 3); + var red = this.GetRed(ref this._cases!, 3); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("cases cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _switchExpression, 1); - case 2: return GetRed(ref _optionalCommas, 2); - case 3: return GetRed(ref _cases, 3); + case 1: return GetRed(ref _switchExpression!, 1); + case 2: return GetRed(ref _optionalCommas!, 2); + case 3: return GetRed(ref _cases!, 3); default: return null; } } @@ -297,9 +307,9 @@ namespace Parser public class SwitchCaseSyntaxNode : SyntaxNode { - private SyntaxNode _caseIdentifier; - private SyntaxNode _optionalCommas; - private SyntaxNode _body; + private SyntaxNode? _caseIdentifier; + private SyntaxNode? _optionalCommas; + private SyntaxNode? _body; internal SwitchCaseSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -314,11 +324,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._caseIdentifier, 1); + var red = this.GetRed(ref this._caseIdentifier!, 1); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("caseIdentifier cannot be null"); } } @@ -326,11 +336,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._optionalCommas, 2); + var red = this.GetRed(ref this._optionalCommas!, 2); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("optionalCommas cannot be null"); } } @@ -338,21 +348,21 @@ namespace Parser { get { - var red = this.GetRed(ref this._body, 3); + var red = this.GetRed(ref this._body!, 3); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("body cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _caseIdentifier, 1); - case 2: return GetRed(ref _optionalCommas, 2); - case 3: return GetRed(ref _body, 3); + case 1: return GetRed(ref _caseIdentifier!, 1); + case 2: return GetRed(ref _optionalCommas!, 2); + case 3: return GetRed(ref _body!, 3); default: return null; } } @@ -366,9 +376,9 @@ namespace Parser public class WhileStatementSyntaxNode : StatementSyntaxNode { - private SyntaxNode _condition; - private SyntaxNode _optionalCommas; - private SyntaxNode _body; + private SyntaxNode? _condition; + private SyntaxNode? _optionalCommas; + private SyntaxNode? _body; internal WhileStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -388,11 +398,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._condition, 1); + var red = this.GetRed(ref this._condition!, 1); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("condition cannot be null"); } } @@ -400,11 +410,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._optionalCommas, 2); + var red = this.GetRed(ref this._optionalCommas!, 2); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("optionalCommas cannot be null"); } } @@ -412,21 +422,21 @@ namespace Parser { get { - var red = this.GetRed(ref this._body, 3); + var red = this.GetRed(ref this._body!, 3); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("body cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _condition, 1); - case 2: return GetRed(ref _optionalCommas, 2); - case 3: return GetRed(ref _body, 3); + case 1: return GetRed(ref _condition!, 1); + case 2: return GetRed(ref _optionalCommas!, 2); + case 3: return GetRed(ref _body!, 3); default: return null; } } @@ -440,9 +450,9 @@ namespace Parser public class ElseifClause : SyntaxNode { - private SyntaxNode _condition; - private SyntaxNode _optionalCommas; - private SyntaxNode _body; + private SyntaxNode? _condition; + private SyntaxNode? _optionalCommas; + private SyntaxNode? _body; internal ElseifClause(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -457,11 +467,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._condition, 1); + var red = this.GetRed(ref this._condition!, 1); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("condition cannot be null"); } } @@ -469,11 +479,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._optionalCommas, 2); + var red = this.GetRed(ref this._optionalCommas!, 2); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("optionalCommas cannot be null"); } } @@ -481,21 +491,21 @@ namespace Parser { get { - var red = this.GetRed(ref this._body, 3); + var red = this.GetRed(ref this._body!, 3); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("body cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _condition, 1); - case 2: return GetRed(ref _optionalCommas, 2); - case 3: return GetRed(ref _body, 3); + case 1: return GetRed(ref _condition!, 1); + case 2: return GetRed(ref _optionalCommas!, 2); + case 3: return GetRed(ref _body!, 3); default: return null; } } @@ -509,7 +519,7 @@ namespace Parser public class ElseClause : SyntaxNode { - private SyntaxNode _body; + private SyntaxNode? _body; internal ElseClause(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -524,19 +534,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._body, 1); + var red = this.GetRed(ref this._body!, 1); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("body cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _body, 1); + case 1: return GetRed(ref _body!, 1); default: return null; } } @@ -550,11 +560,11 @@ namespace Parser public class IfStatementSyntaxNode : StatementSyntaxNode { - private SyntaxNode _condition; - private SyntaxNode _optionalCommas; - private SyntaxNode _body; - private SyntaxNode _elseifClauses; - private SyntaxNode _elseClause; + private SyntaxNode? _condition; + private SyntaxNode? _optionalCommas; + private SyntaxNode? _body; + private SyntaxNode? _elseifClauses; + private SyntaxNode? _elseClause; internal IfStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -574,11 +584,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._condition, 1); + var red = this.GetRed(ref this._condition!, 1); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("condition cannot be null"); } } @@ -586,11 +596,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._optionalCommas, 2); + var red = this.GetRed(ref this._optionalCommas!, 2); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("optionalCommas cannot be null"); } } @@ -598,11 +608,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._body, 3); + var red = this.GetRed(ref this._body!, 3); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("body cannot be null"); } } @@ -610,15 +620,15 @@ namespace Parser { get { - var red = this.GetRed(ref this._elseifClauses, 4); + var red = this.GetRed(ref this._elseifClauses!, 4); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("elseifClauses cannot be null"); } } - public ElseClause ElseClause + public ElseClause? ElseClause { get { @@ -630,14 +640,14 @@ namespace Parser } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _condition, 1); - case 2: return GetRed(ref _optionalCommas, 2); - case 3: return GetRed(ref _body, 3); - case 4: return GetRed(ref _elseifClauses, 4); + case 1: return GetRed(ref _condition!, 1); + case 2: return GetRed(ref _optionalCommas!, 2); + case 3: return GetRed(ref _body!, 3); + case 4: return GetRed(ref _elseifClauses!, 4); case 5: return GetRed(ref _elseClause, 5); default: return null; } @@ -652,9 +662,9 @@ namespace Parser public class ForStatementSyntaxNode : StatementSyntaxNode { - private SyntaxNode _assignment; - private SyntaxNode _optionalCommas; - private SyntaxNode _body; + private SyntaxNode? _assignment; + private SyntaxNode? _optionalCommas; + private SyntaxNode? _body; internal ForStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -674,11 +684,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._assignment, 1); + var red = this.GetRed(ref this._assignment!, 1); if (red != null) return (AssignmentExpressionSyntaxNode)red; - return default(AssignmentExpressionSyntaxNode); + throw new System.Exception("assignment cannot be null"); } } @@ -686,11 +696,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._optionalCommas, 2); + var red = this.GetRed(ref this._optionalCommas!, 2); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("optionalCommas cannot be null"); } } @@ -698,21 +708,21 @@ namespace Parser { get { - var red = this.GetRed(ref this._body, 3); + var red = this.GetRed(ref this._body!, 3); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("body cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _assignment, 1); - case 2: return GetRed(ref _optionalCommas, 2); - case 3: return GetRed(ref _body, 3); + case 1: return GetRed(ref _assignment!, 1); + case 2: return GetRed(ref _optionalCommas!, 2); + case 3: return GetRed(ref _body!, 3); default: return null; } } @@ -726,8 +736,8 @@ namespace Parser public class AssignmentExpressionSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _lhs; - private SyntaxNode _rhs; + private SyntaxNode? _lhs; + private SyntaxNode? _rhs; internal AssignmentExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -742,11 +752,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._lhs, 0); + var red = this.GetRed(ref this._lhs!, 0); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("lhs cannot be null"); } } @@ -754,20 +764,20 @@ namespace Parser { get { - var red = this.GetRed(ref this._rhs, 2); + var red = this.GetRed(ref this._rhs!, 2); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("rhs cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _lhs, 0); - case 2: return GetRed(ref _rhs, 2); + case 0: return GetRed(ref _lhs!, 0); + case 2: return GetRed(ref _rhs!, 2); default: return null; } } @@ -781,7 +791,7 @@ namespace Parser public class CatchClauseSyntaxNode : SyntaxNode { - private SyntaxNode _catchBody; + private SyntaxNode? _catchBody; internal CatchClauseSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -796,19 +806,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._catchBody, 1); + var red = this.GetRed(ref this._catchBody!, 1); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("catchBody cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _catchBody, 1); + case 1: return GetRed(ref _catchBody!, 1); default: return null; } } @@ -822,8 +832,8 @@ namespace Parser public class TryCatchStatementSyntaxNode : StatementSyntaxNode { - private SyntaxNode _tryBody; - private SyntaxNode _catchClause; + private SyntaxNode? _tryBody; + private SyntaxNode? _catchClause; internal TryCatchStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -843,15 +853,15 @@ namespace Parser { get { - var red = this.GetRed(ref this._tryBody, 1); + var red = this.GetRed(ref this._tryBody!, 1); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("tryBody cannot be null"); } } - public CatchClauseSyntaxNode CatchClause + public CatchClauseSyntaxNode? CatchClause { get { @@ -863,11 +873,11 @@ namespace Parser } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _tryBody, 1); + case 1: return GetRed(ref _tryBody!, 1); case 2: return GetRed(ref _catchClause, 2); default: return null; } @@ -882,7 +892,7 @@ namespace Parser public class ExpressionStatementSyntaxNode : StatementSyntaxNode { - private SyntaxNode _expression; + private SyntaxNode? _expression; internal ExpressionStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -893,19 +903,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._expression, 0); + var red = this.GetRed(ref this._expression!, 0); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("expression cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _expression, 0); + case 0: return GetRed(ref _expression!, 0); default: return null; } } @@ -930,7 +940,7 @@ namespace Parser } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { @@ -954,7 +964,7 @@ namespace Parser - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { @@ -971,7 +981,7 @@ namespace Parser public class UnaryPrefixOperationExpressionSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _operand; + private SyntaxNode? _operand; internal UnaryPrefixOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -986,19 +996,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._operand, 1); + var red = this.GetRed(ref this._operand!, 1); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("operand cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _operand, 1); + case 1: return GetRed(ref _operand!, 1); default: return null; } } @@ -1012,7 +1022,7 @@ namespace Parser public class CompoundNameSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _nodes; + private SyntaxNode? _nodes; internal CompoundNameSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1023,19 +1033,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._nodes, 0); + var red = this.GetRed(ref this._nodes!, 0); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("nodes cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _nodes, 0); + case 0: return GetRed(ref _nodes!, 0); default: return null; } } @@ -1049,7 +1059,7 @@ namespace Parser public class NamedFunctionHandleSyntaxNode : FunctionHandleSyntaxNode { - private SyntaxNode _functionName; + private SyntaxNode? _functionName; internal NamedFunctionHandleSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1064,19 +1074,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._functionName, 1); + var red = this.GetRed(ref this._functionName!, 1); if (red != null) return (CompoundNameSyntaxNode)red; - return default(CompoundNameSyntaxNode); + throw new System.Exception("functionName cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _functionName, 1); + case 1: return GetRed(ref _functionName!, 1); default: return null; } } @@ -1090,8 +1100,8 @@ namespace Parser public class LambdaSyntaxNode : FunctionHandleSyntaxNode { - private SyntaxNode _input; - private SyntaxNode _body; + private SyntaxNode? _input; + private SyntaxNode? _body; internal LambdaSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1106,11 +1116,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._input, 1); + var red = this.GetRed(ref this._input!, 1); if (red != null) return (FunctionInputDescriptionSyntaxNode)red; - return default(FunctionInputDescriptionSyntaxNode); + throw new System.Exception("input cannot be null"); } } @@ -1118,20 +1128,20 @@ namespace Parser { get { - var red = this.GetRed(ref this._body, 2); + var red = this.GetRed(ref this._body!, 2); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("body cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _input, 1); - case 2: return GetRed(ref _body, 2); + case 1: return GetRed(ref _input!, 1); + case 2: return GetRed(ref _body!, 2); default: return null; } } @@ -1145,8 +1155,8 @@ namespace Parser public class BinaryOperationExpressionSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _lhs; - private SyntaxNode _rhs; + private SyntaxNode? _lhs; + private SyntaxNode? _rhs; internal BinaryOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1161,11 +1171,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._lhs, 0); + var red = this.GetRed(ref this._lhs!, 0); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("lhs cannot be null"); } } @@ -1173,20 +1183,20 @@ namespace Parser { get { - var red = this.GetRed(ref this._rhs, 2); + var red = this.GetRed(ref this._rhs!, 2); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("rhs cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _lhs, 0); - case 2: return GetRed(ref _rhs, 2); + case 0: return GetRed(ref _lhs!, 0); + case 2: return GetRed(ref _rhs!, 2); default: return null; } } @@ -1211,7 +1221,7 @@ namespace Parser } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { @@ -1239,7 +1249,7 @@ namespace Parser } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { @@ -1267,7 +1277,7 @@ namespace Parser } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { @@ -1295,7 +1305,7 @@ namespace Parser } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { @@ -1323,7 +1333,7 @@ namespace Parser } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { @@ -1340,7 +1350,7 @@ namespace Parser public class ArrayLiteralExpressionSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _nodes; + private SyntaxNode? _nodes; internal ArrayLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1360,19 +1370,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._nodes, 1); + var red = this.GetRed(ref this._nodes!, 1); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("nodes cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _nodes, 1); + case 1: return GetRed(ref _nodes!, 1); default: return null; } } @@ -1386,7 +1396,7 @@ namespace Parser public class CellArrayLiteralExpressionSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _nodes; + private SyntaxNode? _nodes; internal CellArrayLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1406,19 +1416,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._nodes, 1); + var red = this.GetRed(ref this._nodes!, 1); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("nodes cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _nodes, 1); + case 1: return GetRed(ref _nodes!, 1); default: return null; } } @@ -1432,7 +1442,7 @@ namespace Parser public class ParenthesizedExpressionSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _expression; + private SyntaxNode? _expression; internal ParenthesizedExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1452,19 +1462,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._expression, 1); + var red = this.GetRed(ref this._expression!, 1); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("expression cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _expression, 1); + case 1: return GetRed(ref _expression!, 1); default: return null; } } @@ -1478,8 +1488,8 @@ namespace Parser public class CellArrayElementAccessExpressionSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _expression; - private SyntaxNode _nodes; + private SyntaxNode? _expression; + private SyntaxNode? _nodes; internal CellArrayElementAccessExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1499,11 +1509,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._expression, 0); + var red = this.GetRed(ref this._expression!, 0); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("expression cannot be null"); } } @@ -1511,20 +1521,20 @@ namespace Parser { get { - var red = this.GetRed(ref this._nodes, 2); + var red = this.GetRed(ref this._nodes!, 2); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("nodes cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _expression, 0); - case 2: return GetRed(ref _nodes, 2); + case 0: return GetRed(ref _expression!, 0); + case 2: return GetRed(ref _nodes!, 2); default: return null; } } @@ -1538,8 +1548,8 @@ namespace Parser public class FunctionCallExpressionSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _functionName; - private SyntaxNode _nodes; + private SyntaxNode? _functionName; + private SyntaxNode? _nodes; internal FunctionCallExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1559,11 +1569,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._functionName, 0); + var red = this.GetRed(ref this._functionName!, 0); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("functionName cannot be null"); } } @@ -1571,20 +1581,20 @@ namespace Parser { get { - var red = this.GetRed(ref this._nodes, 2); + var red = this.GetRed(ref this._nodes!, 2); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("nodes cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _functionName, 0); - case 2: return GetRed(ref _nodes, 2); + case 0: return GetRed(ref _functionName!, 0); + case 2: return GetRed(ref _nodes!, 2); default: return null; } } @@ -1598,8 +1608,8 @@ namespace Parser public class MemberAccessSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _leftOperand; - private SyntaxNode _rightOperand; + private SyntaxNode? _leftOperand; + private SyntaxNode? _rightOperand; internal MemberAccessSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1614,11 +1624,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._leftOperand, 0); + var red = this.GetRed(ref this._leftOperand!, 0); if (red != null) return (SyntaxNode)red; - return default(SyntaxNode); + throw new System.Exception("leftOperand cannot be null"); } } @@ -1626,20 +1636,20 @@ namespace Parser { get { - var red = this.GetRed(ref this._rightOperand, 2); + var red = this.GetRed(ref this._rightOperand!, 2); if (red != null) return (SyntaxNode)red; - return default(SyntaxNode); + throw new System.Exception("rightOperand cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _leftOperand, 0); - case 2: return GetRed(ref _rightOperand, 2); + case 0: return GetRed(ref _leftOperand!, 0); + case 2: return GetRed(ref _rightOperand!, 2); default: return null; } } @@ -1653,7 +1663,7 @@ namespace Parser public class UnaryPostixOperationExpressionSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _operand; + private SyntaxNode? _operand; internal UnaryPostixOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1668,19 +1678,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._operand, 0); + var red = this.GetRed(ref this._operand!, 0); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("operand cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _operand, 0); + case 0: return GetRed(ref _operand!, 0); default: return null; } } @@ -1694,7 +1704,7 @@ namespace Parser public class IndirectMemberAccessSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _expression; + private SyntaxNode? _expression; internal IndirectMemberAccessSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1714,19 +1724,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._expression, 1); + var red = this.GetRed(ref this._expression!, 1); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("expression cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _expression, 1); + case 1: return GetRed(ref _expression!, 1); default: return null; } } @@ -1740,8 +1750,8 @@ namespace Parser public class CommandExpressionSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _commandName; - private SyntaxNode _arguments; + private SyntaxNode? _commandName; + private SyntaxNode? _arguments; internal CommandExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1752,11 +1762,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._commandName, 0); + var red = this.GetRed(ref this._commandName!, 0); if (red != null) return (IdentifierNameSyntaxNode)red; - return default(IdentifierNameSyntaxNode); + throw new System.Exception("commandName cannot be null"); } } @@ -1764,20 +1774,20 @@ namespace Parser { get { - var red = this.GetRed(ref this._arguments, 1); + var red = this.GetRed(ref this._arguments!, 1); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("arguments cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _commandName, 0); - case 1: return GetRed(ref _arguments, 1); + case 0: return GetRed(ref _commandName!, 0); + case 1: return GetRed(ref _arguments!, 1); default: return null; } } @@ -1791,8 +1801,8 @@ namespace Parser public class BaseClassInvokationSyntaxNode : ExpressionSyntaxNode { - private SyntaxNode _methodName; - private SyntaxNode _baseClassNameAndArguments; + private SyntaxNode? _methodName; + private SyntaxNode? _baseClassNameAndArguments; internal BaseClassInvokationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1807,11 +1817,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._methodName, 0); + var red = this.GetRed(ref this._methodName!, 0); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("methodName cannot be null"); } } @@ -1819,20 +1829,20 @@ namespace Parser { get { - var red = this.GetRed(ref this._baseClassNameAndArguments, 2); + var red = this.GetRed(ref this._baseClassNameAndArguments!, 2); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("baseClassNameAndArguments cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _methodName, 0); - case 2: return GetRed(ref _baseClassNameAndArguments, 2); + case 0: return GetRed(ref _methodName!, 0); + case 2: return GetRed(ref _baseClassNameAndArguments!, 2); default: return null; } } @@ -1846,7 +1856,7 @@ namespace Parser public class AttributeAssignmentSyntaxNode : SyntaxNode { - private SyntaxNode _value; + private SyntaxNode? _value; internal AttributeAssignmentSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1861,19 +1871,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._value, 1); + var red = this.GetRed(ref this._value!, 1); if (red != null) return (ExpressionSyntaxNode)red; - return default(ExpressionSyntaxNode); + throw new System.Exception("value cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _value, 1); + case 1: return GetRed(ref _value!, 1); default: return null; } } @@ -1887,8 +1897,8 @@ namespace Parser public class AttributeSyntaxNode : SyntaxNode { - private SyntaxNode _name; - private SyntaxNode _assignment; + private SyntaxNode? _name; + private SyntaxNode? _assignment; internal AttributeSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1899,15 +1909,15 @@ namespace Parser { get { - var red = this.GetRed(ref this._name, 0); + var red = this.GetRed(ref this._name!, 0); if (red != null) return (IdentifierNameSyntaxNode)red; - return default(IdentifierNameSyntaxNode); + throw new System.Exception("name cannot be null"); } } - public AttributeAssignmentSyntaxNode Assignment + public AttributeAssignmentSyntaxNode? Assignment { get { @@ -1919,11 +1929,11 @@ namespace Parser } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _name, 0); + case 0: return GetRed(ref _name!, 0); case 1: return GetRed(ref _assignment, 1); default: return null; } @@ -1938,7 +1948,7 @@ namespace Parser public class AttributeListSyntaxNode : SyntaxNode { - private SyntaxNode _nodes; + private SyntaxNode? _nodes; internal AttributeListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1958,19 +1968,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._nodes, 1); + var red = this.GetRed(ref this._nodes!, 1); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("nodes cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _nodes, 1); + case 1: return GetRed(ref _nodes!, 1); default: return null; } } @@ -1984,11 +1994,12 @@ namespace Parser public class MethodDefinitionSyntaxNode : MethodDeclarationSyntaxNode { - private SyntaxNode _outputDescription; - private SyntaxNode _name; - private SyntaxNode _inputDescription; - private SyntaxNode _commas; - private SyntaxNode _body; + private SyntaxNode? _outputDescription; + private SyntaxNode? _name; + private SyntaxNode? _inputDescription; + private SyntaxNode? _commas; + private SyntaxNode? _body; + private SyntaxNode? _endKeyword; internal MethodDefinitionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -1999,12 +2010,7 @@ namespace Parser get { return new SyntaxToken(this, ((Parser.Internal.MethodDefinitionSyntaxNode)_green)._functionKeyword, this.GetChildPosition(0)); } } - public SyntaxToken EndKeyword - { - get { return new SyntaxToken(this, ((Parser.Internal.MethodDefinitionSyntaxNode)_green)._endKeyword, this.GetChildPosition(6)); } - } - - public FunctionOutputDescriptionSyntaxNode OutputDescription + public FunctionOutputDescriptionSyntaxNode? OutputDescription { get { @@ -2020,15 +2026,15 @@ namespace Parser { get { - var red = this.GetRed(ref this._name, 2); + var red = this.GetRed(ref this._name!, 2); if (red != null) return (CompoundNameSyntaxNode)red; - return default(CompoundNameSyntaxNode); + throw new System.Exception("name cannot be null"); } } - public FunctionInputDescriptionSyntaxNode InputDescription + public FunctionInputDescriptionSyntaxNode? InputDescription { get { @@ -2044,11 +2050,11 @@ namespace Parser { get { - var red = this.GetRed(ref this._commas, 4); + var red = this.GetRed(ref this._commas!, 4); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("commas cannot be null"); } } @@ -2056,23 +2062,36 @@ namespace Parser { get { - var red = this.GetRed(ref this._body, 5); + var red = this.GetRed(ref this._body!, 5); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("body cannot be null"); } } - internal override SyntaxNode GetNode(int i) + public EndKeywordSyntaxNode? EndKeyword + { + get + { + var red = this.GetRed(ref this._endKeyword, 6); + if (red != null) + return (EndKeywordSyntaxNode)red; + + return default(EndKeywordSyntaxNode); + } + } + + internal override SyntaxNode? GetNode(int i) { switch (i) { case 1: return GetRed(ref _outputDescription, 1); - case 2: return GetRed(ref _name, 2); + case 2: return GetRed(ref _name!, 2); case 3: return GetRed(ref _inputDescription, 3); - case 4: return GetRed(ref _commas, 4); - case 5: return GetRed(ref _body, 5); + case 4: return GetRed(ref _commas!, 4); + case 5: return GetRed(ref _body!, 5); + case 6: return GetRed(ref _endKeyword, 6); default: return null; } } @@ -2086,16 +2105,16 @@ namespace Parser public class AbstractMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode { - private SyntaxNode _outputDescription; - private SyntaxNode _name; - private SyntaxNode _inputDescription; + private SyntaxNode? _outputDescription; + private SyntaxNode? _name; + private SyntaxNode? _inputDescription; internal AbstractMethodDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { } - public FunctionOutputDescriptionSyntaxNode OutputDescription + public FunctionOutputDescriptionSyntaxNode? OutputDescription { get { @@ -2111,15 +2130,15 @@ namespace Parser { get { - var red = this.GetRed(ref this._name, 1); + var red = this.GetRed(ref this._name!, 1); if (red != null) return (CompoundNameSyntaxNode)red; - return default(CompoundNameSyntaxNode); + throw new System.Exception("name cannot be null"); } } - public FunctionInputDescriptionSyntaxNode InputDescription + public FunctionInputDescriptionSyntaxNode? InputDescription { get { @@ -2131,12 +2150,12 @@ namespace Parser } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { case 0: return GetRed(ref _outputDescription, 0); - case 1: return GetRed(ref _name, 1); + case 1: return GetRed(ref _name!, 1); case 2: return GetRed(ref _inputDescription, 2); default: return null; } @@ -2151,8 +2170,8 @@ namespace Parser public class MethodsListSyntaxNode : SyntaxNode { - private SyntaxNode _attributes; - private SyntaxNode _methods; + private SyntaxNode? _attributes; + private SyntaxNode? _methods; internal MethodsListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -2168,7 +2187,7 @@ namespace Parser get { return new SyntaxToken(this, ((Parser.Internal.MethodsListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); } } - public AttributeListSyntaxNode Attributes + public AttributeListSyntaxNode? Attributes { get { @@ -2184,20 +2203,20 @@ namespace Parser { get { - var red = this.GetRed(ref this._methods, 2); + var red = this.GetRed(ref this._methods!, 2); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("methods cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { case 1: return GetRed(ref _attributes, 1); - case 2: return GetRed(ref _methods, 2); + case 2: return GetRed(ref _methods!, 2); default: return null; } } @@ -2211,8 +2230,8 @@ namespace Parser public class PropertiesListSyntaxNode : SyntaxNode { - private SyntaxNode _attributes; - private SyntaxNode _properties; + private SyntaxNode? _attributes; + private SyntaxNode? _properties; internal PropertiesListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -2228,7 +2247,7 @@ namespace Parser get { return new SyntaxToken(this, ((Parser.Internal.PropertiesListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); } } - public AttributeListSyntaxNode Attributes + public AttributeListSyntaxNode? Attributes { get { @@ -2244,20 +2263,20 @@ namespace Parser { get { - var red = this.GetRed(ref this._properties, 2); + var red = this.GetRed(ref this._properties!, 2); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("properties cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { case 1: return GetRed(ref _attributes, 1); - case 2: return GetRed(ref _properties, 2); + case 2: return GetRed(ref _properties!, 2); default: return null; } } @@ -2271,7 +2290,7 @@ namespace Parser public class BaseClassListSyntaxNode : SyntaxNode { - private SyntaxNode _baseClasses; + private SyntaxNode? _baseClasses; internal BaseClassListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -2286,19 +2305,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._baseClasses, 1); + var red = this.GetRed(ref this._baseClasses!, 1); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("baseClasses cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _baseClasses, 1); + case 1: return GetRed(ref _baseClasses!, 1); default: return null; } } @@ -2312,10 +2331,10 @@ namespace Parser public class ClassDeclarationSyntaxNode : StatementSyntaxNode { - private SyntaxNode _attributes; - private SyntaxNode _className; - private SyntaxNode _baseClassList; - private SyntaxNode _nodes; + private SyntaxNode? _attributes; + private SyntaxNode? _className; + private SyntaxNode? _baseClassList; + private SyntaxNode? _nodes; internal ClassDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -2331,7 +2350,7 @@ namespace Parser get { return new SyntaxToken(this, ((Parser.Internal.ClassDeclarationSyntaxNode)_green)._endKeyword, this.GetChildPosition(5)); } } - public AttributeListSyntaxNode Attributes + public AttributeListSyntaxNode? Attributes { get { @@ -2347,15 +2366,15 @@ namespace Parser { get { - var red = this.GetRed(ref this._className, 2); + var red = this.GetRed(ref this._className!, 2); if (red != null) return (IdentifierNameSyntaxNode)red; - return default(IdentifierNameSyntaxNode); + throw new System.Exception("className cannot be null"); } } - public BaseClassListSyntaxNode BaseClassList + public BaseClassListSyntaxNode? BaseClassList { get { @@ -2371,22 +2390,22 @@ namespace Parser { get { - var red = this.GetRed(ref this._nodes, 4); + var red = this.GetRed(ref this._nodes!, 4); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("nodes cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { case 1: return GetRed(ref _attributes, 1); - case 2: return GetRed(ref _className, 2); + case 2: return GetRed(ref _className!, 2); case 3: return GetRed(ref _baseClassList, 3); - case 4: return GetRed(ref _nodes, 4); + case 4: return GetRed(ref _nodes!, 4); default: return null; } } @@ -2400,7 +2419,7 @@ namespace Parser public class EnumerationItemValueSyntaxNode : SyntaxNode { - private SyntaxNode _values; + private SyntaxNode? _values; internal EnumerationItemValueSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -2420,19 +2439,19 @@ namespace Parser { get { - var red = this.GetRed(ref this._values, 1); + var red = this.GetRed(ref this._values!, 1); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("values cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 1: return GetRed(ref _values, 1); + case 1: return GetRed(ref _values!, 1); default: return null; } } @@ -2446,9 +2465,9 @@ namespace Parser public class EnumerationItemSyntaxNode : SyntaxNode { - private SyntaxNode _name; - private SyntaxNode _values; - private SyntaxNode _commas; + private SyntaxNode? _name; + private SyntaxNode? _values; + private SyntaxNode? _commas; internal EnumerationItemSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -2459,15 +2478,15 @@ namespace Parser { get { - var red = this.GetRed(ref this._name, 0); + var red = this.GetRed(ref this._name!, 0); if (red != null) return (IdentifierNameSyntaxNode)red; - return default(IdentifierNameSyntaxNode); + throw new System.Exception("name cannot be null"); } } - public EnumerationItemValueSyntaxNode Values + public EnumerationItemValueSyntaxNode? Values { get { @@ -2483,21 +2502,21 @@ namespace Parser { get { - var red = this.GetRed(ref this._commas, 2); + var red = this.GetRed(ref this._commas!, 2); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("commas cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { - case 0: return GetRed(ref _name, 0); + case 0: return GetRed(ref _name!, 0); case 1: return GetRed(ref _values, 1); - case 2: return GetRed(ref _commas, 2); + case 2: return GetRed(ref _commas!, 2); default: return null; } } @@ -2511,8 +2530,8 @@ namespace Parser public class EnumerationListSyntaxNode : SyntaxNode { - private SyntaxNode _attributes; - private SyntaxNode _items; + private SyntaxNode? _attributes; + private SyntaxNode? _items; internal EnumerationListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -2528,7 +2547,7 @@ namespace Parser get { return new SyntaxToken(this, ((Parser.Internal.EnumerationListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); } } - public AttributeListSyntaxNode Attributes + public AttributeListSyntaxNode? Attributes { get { @@ -2544,20 +2563,20 @@ namespace Parser { get { - var red = this.GetRed(ref this._items, 2); + var red = this.GetRed(ref this._items!, 2); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("items cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { case 1: return GetRed(ref _attributes, 1); - case 2: return GetRed(ref _items, 2); + case 2: return GetRed(ref _items!, 2); default: return null; } } @@ -2571,8 +2590,8 @@ namespace Parser public class EventsListSyntaxNode : SyntaxNode { - private SyntaxNode _attributes; - private SyntaxNode _events; + private SyntaxNode? _attributes; + private SyntaxNode? _events; internal EventsListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) { @@ -2588,7 +2607,7 @@ namespace Parser get { return new SyntaxToken(this, ((Parser.Internal.EventsListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); } } - public AttributeListSyntaxNode Attributes + public AttributeListSyntaxNode? Attributes { get { @@ -2604,20 +2623,20 @@ namespace Parser { get { - var red = this.GetRed(ref this._events, 2); + var red = this.GetRed(ref this._events!, 2); if (red != null) return (SyntaxNodeOrTokenList)red; - return default(SyntaxNodeOrTokenList); + throw new System.Exception("events cannot be null"); } } - internal override SyntaxNode GetNode(int i) + internal override SyntaxNode? GetNode(int i) { switch (i) { case 1: return GetRed(ref _attributes, 1); - case 2: return GetRed(ref _events, 2); + case 2: return GetRed(ref _events!, 2); default: return null; } } @@ -2628,4 +2647,32 @@ namespace Parser } } + + public class EndKeywordSyntaxNode : SyntaxNode + { + + internal EndKeywordSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + { + } + + public SyntaxToken EndKeyword + { + get { return new SyntaxToken(this, ((Parser.Internal.EndKeywordSyntaxNode)_green)._endKeyword, this.GetChildPosition(0)); } + } + + + internal override SyntaxNode? GetNode(int i) + { + switch (i) + { + default: return null; + } + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitEndKeyword(this); + } + + } } diff --git a/Parser/SyntaxNode.cs b/Parser/SyntaxNode.cs index 3031945..e3db3e6 100644 --- a/Parser/SyntaxNode.cs +++ b/Parser/SyntaxNode.cs @@ -7,7 +7,7 @@ namespace Parser public abstract class SyntaxNode { private readonly SyntaxNode _parent; - internal readonly Internal.GreenNode _green; + internal readonly Internal.GreenNode _green; internal SyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) { _parent = parent; @@ -15,6 +15,13 @@ namespace Parser Position = position; } + private protected SyntaxNode(Internal.GreenNode green, int position) + { + _parent = this; + _green = green; + Position = position; + } + public TokenKind Kind => _green.Kind; public SyntaxNode Parent => _parent; @@ -43,9 +50,9 @@ namespace Parser return result; } - internal abstract SyntaxNode GetNode(int index); + internal abstract SyntaxNode? GetNode(int index); - internal SyntaxNode GetRed(ref SyntaxNode field, int slot) + internal SyntaxNode? GetRed(ref SyntaxNode? field, int slot) { if (field == null) { @@ -89,6 +96,35 @@ namespace Parser } public abstract void Accept(SyntaxVisitor visitor); + + public SyntaxDiagnostic[] GetDiagnostics() + { + return GetDiagnosticsRecursive(_green, Position).ToArray(); + } + + private static IEnumerable GetDiagnosticsRecursive(Internal.GreenNode node, int position) + { + if (node.HasDiagnostics) + { + foreach (var diagnostic in node.GetDiagnostics()) + { + yield return SyntaxDiagnostic.From(diagnostic, position); + } + } + + for (var i = 0; i < node.Slots; i++) + { + var maybeChild = node.GetSlot(i); + if (maybeChild is Internal.GreenNode child) { + foreach (var diagnostic in GetDiagnosticsRecursive(child, position)) + { + yield return diagnostic; + } + + position += child.FullWidth; + } + } + } } public abstract class StatementSyntaxNode : SyntaxNode @@ -119,4 +155,35 @@ namespace Parser } } + public class RootSyntaxNode : SyntaxNode + { + private SyntaxNode? _file; + + internal RootSyntaxNode(Internal.GreenNode green, int position) : base(green, position) + { + } + + internal override SyntaxNode? GetNode(int index) + { + throw new System.NotImplementedException(); + } + + public override void Accept(SyntaxVisitor visitor) + { + throw new System.NotImplementedException(); + } + + + public FileSyntaxNode File + { + get + { + var red = this.GetRed(ref this._file, 0); + if (red != null) + return (FileSyntaxNode)red; + + throw new System.Exception("file cannot be null"); + } + } + } } \ No newline at end of file diff --git a/Parser/SyntaxNodeOrToken.cs b/Parser/SyntaxNodeOrToken.cs index c81330e..775ca93 100644 --- a/Parser/SyntaxNodeOrToken.cs +++ b/Parser/SyntaxNodeOrToken.cs @@ -2,7 +2,7 @@ { public struct SyntaxNodeOrToken { - private readonly Internal.GreenNode _token; + private readonly Internal.GreenNode? _token; private readonly SyntaxNode _nodeOrParent; private readonly bool _isToken; @@ -27,7 +27,7 @@ public int Position { get; } - public SyntaxNode AsNode() + public SyntaxNode? AsNode() { if (_isToken) { @@ -43,7 +43,7 @@ { return default(SyntaxToken); } - return new SyntaxToken(_nodeOrParent, _token, Position); + return new SyntaxToken(_nodeOrParent, _token!, Position); } public static implicit operator SyntaxNodeOrToken(SyntaxToken token) diff --git a/Parser/SyntaxNodeOrTokenList.cs b/Parser/SyntaxNodeOrTokenList.cs index 2e69337..336cff7 100644 --- a/Parser/SyntaxNodeOrTokenList.cs +++ b/Parser/SyntaxNodeOrTokenList.cs @@ -24,7 +24,7 @@ namespace Parser } else { - return green.CreateRed(this, this.GetChildPosition(index)); + return green!.CreateRed(this, this.GetChildPosition(index)); } } throw new ArgumentOutOfRangeException(); @@ -81,7 +81,7 @@ namespace Parser public int Count => _green.Slots; - internal override SyntaxNode GetNode(int index) + internal override SyntaxNode? GetNode(int index) { if (index < _green.Slots) { diff --git a/Parser/SyntaxToken.cs b/Parser/SyntaxToken.cs index b62f474..e0c27f1 100644 --- a/Parser/SyntaxToken.cs +++ b/Parser/SyntaxToken.cs @@ -12,7 +12,7 @@ namespace Parser public TokenKind Kind => _token.Kind; - public override string ToString() + public override string? ToString() { return _token.ToString(); } @@ -34,7 +34,7 @@ namespace Parser return Equals(_parent, other._parent) && Equals(_token, other._token); } - public override bool Equals(object obj) + public override bool Equals(object? obj) { if (ReferenceEquals(null, obj)) return false; return obj is SyntaxToken token && Equals(token); diff --git a/Parser/SyntaxTrivia.cs b/Parser/SyntaxTrivia.cs index 0b4a8c0..15f5424 100644 --- a/Parser/SyntaxTrivia.cs +++ b/Parser/SyntaxTrivia.cs @@ -22,7 +22,7 @@ namespace Parser return Equals(_parent, other._parent) && Equals(_trivia, other._trivia); } - public override bool Equals(object obj) + public override bool Equals(object? obj) { if (ReferenceEquals(null, obj)) return false; return obj is SyntaxTrivia trivia && Equals(trivia); diff --git a/Parser/SyntaxVisitor.Generated.cs b/Parser/SyntaxVisitor.Generated.cs index 41e133b..c3f5585 100644 --- a/Parser/SyntaxVisitor.Generated.cs +++ b/Parser/SyntaxVisitor.Generated.cs @@ -1,3 +1,4 @@ +#nullable enable namespace Parser { public partial class SyntaxVisitor @@ -251,5 +252,10 @@ namespace Parser { DefaultVisit(node); } + + public virtual void VisitEndKeyword(EndKeywordSyntaxNode node) + { + DefaultVisit(node); + } } }; \ No newline at end of file diff --git a/Parser/SyntaxVisitor.cs b/Parser/SyntaxVisitor.cs index fc81561..b03fd73 100644 --- a/Parser/SyntaxVisitor.cs +++ b/Parser/SyntaxVisitor.cs @@ -2,7 +2,7 @@ { public abstract partial class SyntaxVisitor { - public virtual void Visit(SyntaxNode node) + public virtual void Visit(SyntaxNode? node) { node?.Accept(this); } diff --git a/Parser/TextWindow.cs b/Parser/TextWindow.cs index 41d4dc5..3a604a2 100644 --- a/Parser/TextWindow.cs +++ b/Parser/TextWindow.cs @@ -6,7 +6,7 @@ private Position _position; public Position Position => _position; - public TextWindow(string text, string fileName = null) + public TextWindow(string text, string? fileName = null) { Text = text; _position = new Position diff --git a/Parser/TextWindowWithNull.cs b/Parser/TextWindowWithNull.cs index 70d1aee..36d6304 100644 --- a/Parser/TextWindowWithNull.cs +++ b/Parser/TextWindowWithNull.cs @@ -2,7 +2,7 @@ { public class TextWindowWithNull : TextWindow { - public TextWindowWithNull(string text, string fileName = null) : base(text, fileName) + public TextWindowWithNull(string text, string? fileName = null) : base(text, fileName) { } diff --git a/Parser/TokenKind.cs b/Parser/TokenKind.cs index e614836..52e455c 100644 --- a/Parser/TokenKind.cs +++ b/Parser/TokenKind.cs @@ -271,5 +271,7 @@ // ToggleSomething // end EventsList, + EndKeyword, + Root } } \ No newline at end of file diff --git a/Repl/Repl.csproj b/Repl/Repl.csproj index b6b87fa..d84edae 100644 --- a/Repl/Repl.csproj +++ b/Repl/Repl.csproj @@ -1,7 +1,7 @@ - + - netstandard2.0 + netcoreapp3.0 diff --git a/Semantics/Semantics.csproj b/Semantics/Semantics.csproj index 11924a6..6999070 100644 --- a/Semantics/Semantics.csproj +++ b/Semantics/Semantics.csproj @@ -1,6 +1,6 @@  - netstandard2.0 + netcoreapp3.0 diff --git a/SyntaxGenerator/GenerateSyntax.cs b/SyntaxGenerator/GenerateSyntax.cs index 10ca108..24fb42a 100644 --- a/SyntaxGenerator/GenerateSyntax.cs +++ b/SyntaxGenerator/GenerateSyntax.cs @@ -15,7 +15,7 @@ namespace SyntaxGenerator private static readonly List<(string visitorMethodName, string className)> Visitors = new List<(string, string)>(); - private static string _outputPath; + private static readonly string _outputPath; static GenerateSyntax() { @@ -62,12 +62,14 @@ namespace SyntaxGenerator private static string GenerateInternalFieldDeclaration(FieldDescription field) { - return $" internal readonly {field.FieldType} _{field.FieldName};\n"; + return $" internal readonly {FullFieldType(field)} _{field.FieldName};\n"; } private static string GeneratePrivateFieldDeclaration(FieldDescription field) { - return $" private SyntaxNode _{field.FieldName};\n"; + //var typeDeclaration = field.FieldIsNullable ? "SyntaxNode?" : "SyntaxNode"; + var typeDeclaration = "SyntaxNode?"; + return $" private {typeDeclaration} _{field.FieldName};\n"; } private static string GenerateFieldAssignmentInsideConstructor(FieldDescription field) @@ -76,20 +78,41 @@ namespace SyntaxGenerator var fieldAssignment = $" _{field.FieldName} = {field.FieldName};\n"; return widthAdjustment + fieldAssignment; } - - private static string GenerateInternalConstructor(SyntaxNodeDescription node) + + private static string GenerateInternalConstructorSimple(SyntaxNodeDescription node) { var arguments = string.Join( ",", - node.Fields.Select(field => $"\n {field.FieldType} {field.FieldName}")); + node.Fields.Select(field => $"\n {FullFieldType(field)} {field.FieldName}")); var header = - $" internal {node.ClassName}({arguments}) : base(TokenKind.{node.TokenKindName})\n"; - var slotsAssignment = $"\n Slots = {node.Fields.Length};\n"; + $" internal {node.ClassName}({arguments}) : base(TokenKind.{node.TokenKindName})"; + var slotsAssignment = $" Slots = {node.Fields.Length};"; var assignments = string.Join( "", node.Fields.Select(GenerateFieldAssignmentInsideConstructor)); - return header + " {\n" + slotsAssignment + assignments + " }\n"; + return header + "\n {\n" + slotsAssignment + "\n" + assignments + " }\n"; + } + + private static string GenerateInternalConstructorWithDiagnostics(SyntaxNodeDescription node) + { + var arguments = string.Join( + ",", + node.Fields + .Select(field => $"\n {FullFieldType(field)} {field.FieldName}") + .Concat(new[] { $"\n TokenDiagnostic[] diagnostics" })); + var header = + $" internal {node.ClassName}({arguments}) : base(TokenKind.{node.TokenKindName}, diagnostics)"; + var slotsAssignment = $" Slots = {node.Fields.Length};"; + var assignments = string.Join( + "", + node.Fields.Select(GenerateFieldAssignmentInsideConstructor)); + return header + "\n {\n" + slotsAssignment + "\n" + assignments + " }\n"; + } + + private static string GenerateInternalConstructors(SyntaxNodeDescription node) + { + return GenerateInternalConstructorSimple(node) + "\n" + GenerateInternalConstructorWithDiagnostics(node); } private static string GenerateConstructor(SyntaxNodeDescription node) @@ -100,9 +123,21 @@ namespace SyntaxGenerator return header + " {\n }\n"; } + private static string GenerateInternalSetDiagnostics(SyntaxNodeDescription node) + { + var header = $" public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics)"; + var arguments = string.Join( + ", ", + node.Fields + .Select(field => "_" + field.FieldName) + .Concat(new[] { "diagnostics" })); + var text = $" return new {node.ClassName}({arguments});"; + return header + "\n {\n" + text + "\n }\n"; + } + private static string GenerateInternalGetSlot(SyntaxNodeDescription node) { - var header = $" public override GreenNode GetSlot(int i)\n"; + var header = $" public override GreenNode? GetSlot(int i)\n"; var cases = string.Join( "", node.Fields.Select((f, i) => $" case {i}: return _{f.FieldName};\n")); @@ -117,10 +152,16 @@ namespace SyntaxGenerator private static string GenerateGetSlot(SyntaxNodeDescription node, List<(FieldDescription field, int index)> pairs) { - var header = $" internal override SyntaxNode GetNode(int i)\n"; + var header = $" internal override SyntaxNode? GetNode(int i)\n"; + + string GetFieldNameWithPossibleBang(FieldDescription field) + { + return field.FieldIsNullable ? field.FieldName : field.FieldName + "!"; + } + var cases = string.Join( "", - pairs.Select(pair => $" case {pair.index}: return GetRed(ref _{pair.field.FieldName}, {pair.index});\n")); + pairs.Select(pair => $" case {pair.index}: return GetRed(ref _{GetFieldNameWithPossibleBang(pair.field)}, {pair.index});\n")); var defaultCase = " default: return null;\n"; return header + " {\n switch (i)\n {\n" @@ -148,15 +189,17 @@ namespace SyntaxGenerator var fields = string.Join( "", node.Fields.Select(GenerateInternalFieldDeclaration)); - var constructor = GenerateInternalConstructor(node); + var constructor = GenerateInternalConstructors(node); var getSlot = GenerateInternalGetSlot(node); var createRed = GenerateCreateRed(node); + var setDiagnostics = GenerateInternalSetDiagnostics(node); return header + "\n {\n" + fields + "\n" + constructor + "\n" + createRed + "\n" + + setDiagnostics + "\n" + getSlot + " }\n"; } @@ -185,12 +228,17 @@ namespace SyntaxGenerator { type = "SyntaxNodeOrTokenList"; } - var header = $" public {type} {Capitalize(field.FieldName)}\n {{\n get\n {{\n"; + + var typeName = type + (field.FieldIsNullable ? "?" : ""); + var header = $" public {typeName} {Capitalize(field.FieldName)}\n {{\n get\n {{\n"; + var defaultReturnStatement = field.FieldIsNullable ? $"return default({type});" : $"throw new System.Exception(\"{field.FieldName} cannot be null\");"; + + var fieldNameWithPossibleBang = field.FieldIsNullable ? field.FieldName : field.FieldName + "!"; var text = - $" var red = this.GetRed(ref this._{field.FieldName}, {index});\n" + $" var red = this.GetRed(ref this._{fieldNameWithPossibleBang}, {index});\n" + $" if (red != null)\n" + $" return ({type})red;\n\n" - + $" return default({type});\n"; + + $" {defaultReturnStatement}\n"; return header + text + " }\n }\n"; } @@ -257,7 +305,7 @@ namespace SyntaxGenerator private static string GenerateInternalSyntaxNodeFile(SyntaxDescription syntax) { - var header = $"namespace {InternalNamespace}\n"; + var header = $"#nullable enable\nnamespace {InternalNamespace}\n"; var classes = string.Join( "\n", syntax.Nodes.Select(GenerateInternalClass) @@ -267,7 +315,7 @@ namespace SyntaxGenerator private static string GenerateSyntaxNodeFile(SyntaxDescription syntax) { - var header = $"namespace {OuterNamespace}\n"; + var header = $"#nullable enable\nnamespace {OuterNamespace}\n"; var classes = string.Join( "\n", syntax.Nodes.Select(GenerateClass) @@ -287,13 +335,18 @@ namespace SyntaxGenerator } } + private static string FullFieldType(FieldDescription field) + { + return field.FieldIsNullable ? field.FieldType + "?" : field.FieldType; + } + private static string GenerateFactoryMethod(SyntaxNodeDescription node) { var methodName = FactoryMethodNameFromClassName(node.ClassName); var header = $" public {node.ClassName} {methodName}"; var arguments = string.Join( ", ", - node.Fields.Select(field => $"\n {field.FieldType} {field.FieldName}")); + node.Fields.Select(field => $"\n {FullFieldType(field)} {field.FieldName}")); var constructorParameters = string.Join( ", ", node.Fields.Select(field => $"\n {field.FieldName}")); @@ -305,7 +358,7 @@ namespace SyntaxGenerator private static string GenerateSyntaxFactoryFile(SyntaxDescription syntax) { - var header = $"namespace {InternalNamespace}\n{{\n internal partial class SyntaxFactory\n"; + var header = $"#nullable enable\nnamespace {InternalNamespace}\n{{\n internal partial class SyntaxFactory\n"; var methods = string.Join( "\n", syntax.Nodes.Select(GenerateFactoryMethod) @@ -322,7 +375,7 @@ namespace SyntaxGenerator private static string GenerateSyntaxVisitorFile(SyntaxDescription syntax) { - var header = $"namespace {OuterNamespace}\n{{\n public partial class SyntaxVisitor\n"; + var header = $"#nullable enable\nnamespace {OuterNamespace}\n{{\n public partial class SyntaxVisitor\n"; var methods = string.Join( "\n", Visitors.Select(GenerateVisitor)); @@ -335,8 +388,7 @@ namespace SyntaxGenerator var serializer = new XmlSerializer(typeof(SyntaxDescription)); using (var stream = new FileStream("input.xml", FileMode.Open)) { - var syntax = serializer.Deserialize(stream) as SyntaxDescription; - if (syntax == null) + if (!(serializer.Deserialize(stream) is SyntaxDescription syntax)) { Console.WriteLine("Couldn't deserialize syntax."); return; diff --git a/SyntaxGenerator/SyntaxNodeDescription.cs b/SyntaxGenerator/SyntaxNodeDescription.cs index ef38a0c..9f60038 100644 --- a/SyntaxGenerator/SyntaxNodeDescription.cs +++ b/SyntaxGenerator/SyntaxNodeDescription.cs @@ -34,5 +34,7 @@ namespace SyntaxGenerator public string FieldType { get; set; } [XmlAttribute("Name")] public string FieldName { get; set; } + [XmlAttribute("Nullable")] + public bool FieldIsNullable { get; set; } } } \ No newline at end of file diff --git a/SyntaxGenerator/input.xml b/SyntaxGenerator/input.xml index 1bd4142..09dd3fe 100644 --- a/SyntaxGenerator/input.xml +++ b/SyntaxGenerator/input.xml @@ -6,12 +6,12 @@ - + - + - + @@ -58,7 +58,7 @@ - + @@ -80,7 +80,7 @@ - + @@ -183,7 +183,7 @@ - + @@ -192,27 +192,27 @@ - + - + - + - + - + - + - + @@ -222,9 +222,9 @@ - + - + @@ -235,19 +235,22 @@ - + - + - + + + +