diff --git a/Parser.Tests/MLexerGreenTests.cs b/Parser.Tests/MLexerGreenTests.cs index 1bae4c2..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; diff --git a/Parser.Tests/MParserShould.cs b/Parser.Tests/MParserShould.cs index a149205..938abc5 100644 --- a/Parser.Tests/MParserShould.cs +++ b/Parser.Tests/MParserShould.cs @@ -19,6 +19,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 +35,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 +51,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,6 +65,7 @@ namespace Parser.Tests { var sut = GetSut(text); var actual = sut.Parse(); + var diagnostics = actual.Root.GetDiagnostics(); Assert.Collection(actual.Diagnostics, item => Assert.Equal("Unexpected token 'SemicolonToken', expected 'IdentifierToken'.", item.Message)); } @@ -60,8 +76,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 c4a2888..463a884 100644 --- a/Parser.Tests/Parser.Tests.csproj +++ b/Parser.Tests/Parser.Tests.csproj @@ -2,13 +2,16 @@ netcoreapp3.0 false - true + 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/Internal/GreenNode.cs b/Parser/Internal/GreenNode.cs index 502fb1a..7638ff7 100644 --- a/Parser/Internal/GreenNode.cs +++ b/Parser/Internal/GreenNode.cs @@ -11,6 +11,9 @@ namespace Parser.Internal public TokenKind Kind { get; } public int Slots { get; protected set; } 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,6 +26,21 @@ 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; @@ -225,5 +243,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/MParserGreen.cs b/Parser/Internal/MParserGreen.cs index 2460a5c..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(kind, token.Kind); - return TokenFactory.CreateMissing(kind, null, null); + return CreateMissingToken(kind); } _index++; return token; diff --git a/Parser/Internal/SyntaxList.cs b/Parser/Internal/SyntaxList.cs index 6699e0a..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,6 +17,19 @@ namespace Parser.Internal } } + 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]; @@ -40,5 +53,10 @@ namespace Parser.Internal { 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/SyntaxList`1.cs b/Parser/Internal/SyntaxList`1.cs index 3efa41e..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,6 +16,16 @@ } } + protected SyntaxList(T[] list, TokenDiagnostic[] diagnostics) : base(TokenKind.List, diagnostics) + { + 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); @@ -32,5 +44,10 @@ { 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 1841cc0..54d5211 100644 --- a/Parser/Internal/SyntaxNode.Generated.cs +++ b/Parser/Internal/SyntaxNode.Generated.cs @@ -16,11 +16,28 @@ namespace Parser.Internal _endOfFile = endOfFile; } + internal FileSyntaxNode( + SyntaxList statementList, + SyntaxToken endOfFile, + TokenDiagnostic[] diagnostics) : base(TokenKind.File, diagnostics) + { + Slots = 2; + this.AdjustWidth(statementList); + _statementList = statementList; + this.AdjustWidth(endOfFile); + _endOfFile = endOfFile; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.FileSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new FileSyntaxNode(_statementList, _endOfFile, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -68,11 +85,43 @@ namespace Parser.Internal _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; + 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 override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.FunctionDeclarationSyntaxNode(parent, this, position); } + 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) @@ -105,11 +154,28 @@ namespace Parser.Internal _assignmentSign = assignmentSign; } + internal FunctionOutputDescriptionSyntaxNode( + SyntaxList outputList, + SyntaxToken assignmentSign, + TokenDiagnostic[] diagnostics) : base(TokenKind.FunctionOutputDescription, diagnostics) + { + Slots = 2; + this.AdjustWidth(outputList); + _outputList = outputList; + this.AdjustWidth(assignmentSign); + _assignmentSign = assignmentSign; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.FunctionOutputDescriptionSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new FunctionOutputDescriptionSyntaxNode(_outputList, _assignmentSign, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -141,11 +207,31 @@ namespace Parser.Internal _closingBracket = closingBracket; } + internal FunctionInputDescriptionSyntaxNode( + SyntaxToken openingBracket, + SyntaxList parameterList, + SyntaxToken closingBracket, + TokenDiagnostic[] diagnostics) : base(TokenKind.FunctionInputDescription, diagnostics) + { + Slots = 3; + this.AdjustWidth(openingBracket); + _openingBracket = openingBracket; + this.AdjustWidth(parameterList); + _parameterList = parameterList; + this.AdjustWidth(closingBracket); + _closingBracket = closingBracket; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.FunctionInputDescriptionSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new FunctionInputDescriptionSyntaxNode(_openingBracket, _parameterList, _closingBracket, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -186,11 +272,37 @@ namespace Parser.Internal _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; + this.AdjustWidth(switchExpression); + _switchExpression = switchExpression; + this.AdjustWidth(optionalCommas); + _optionalCommas = optionalCommas; + this.AdjustWidth(cases); + _cases = cases; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.SwitchStatementSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new SwitchStatementSyntaxNode(_switchKeyword, _switchExpression, _optionalCommas, _cases, _endKeyword, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -229,11 +341,34 @@ namespace Parser.Internal _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; + this.AdjustWidth(caseIdentifier); + _caseIdentifier = caseIdentifier; + this.AdjustWidth(optionalCommas); + _optionalCommas = optionalCommas; + this.AdjustWidth(body); + _body = body; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.SwitchCaseSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new SwitchCaseSyntaxNode(_caseKeyword, _caseIdentifier, _optionalCommas, _body, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -275,11 +410,37 @@ namespace Parser.Internal _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; + this.AdjustWidth(condition); + _condition = condition; + this.AdjustWidth(optionalCommas); + _optionalCommas = optionalCommas; + this.AdjustWidth(body); + _body = body; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.WhileStatementSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new WhileStatementSyntaxNode(_whileKeyword, _condition, _optionalCommas, _body, _endKeyword, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -318,11 +479,34 @@ namespace Parser.Internal _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; + this.AdjustWidth(condition); + _condition = condition; + this.AdjustWidth(optionalCommas); + _optionalCommas = optionalCommas; + this.AdjustWidth(body); + _body = body; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ElseifClause(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ElseifClause(_elseifKeyword, _condition, _optionalCommas, _body, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -352,11 +536,28 @@ namespace Parser.Internal _body = body; } + internal ElseClause( + SyntaxToken elseKeyword, + SyntaxList body, + TokenDiagnostic[] diagnostics) : base(TokenKind.ElseClause, diagnostics) + { + Slots = 2; + this.AdjustWidth(elseKeyword); + _elseKeyword = elseKeyword; + this.AdjustWidth(body); + _body = body; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ElseClause(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ElseClause(_elseKeyword, _body, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -404,11 +605,43 @@ namespace Parser.Internal _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; + 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 override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.IfStatementSyntaxNode(parent, this, position); } + 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) @@ -453,11 +686,37 @@ namespace Parser.Internal _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; + this.AdjustWidth(assignment); + _assignment = assignment; + this.AdjustWidth(optionalCommas); + _optionalCommas = optionalCommas; + this.AdjustWidth(body); + _body = body; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ForStatementSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ForStatementSyntaxNode(_forKeyword, _assignment, _optionalCommas, _body, _endKeyword, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -492,11 +751,31 @@ namespace Parser.Internal _rhs = rhs; } + internal AssignmentExpressionSyntaxNode( + ExpressionSyntaxNode lhs, + SyntaxToken assignmentSign, + ExpressionSyntaxNode rhs, + TokenDiagnostic[] diagnostics) : base(TokenKind.AssignmentExpression, diagnostics) + { + Slots = 3; + this.AdjustWidth(lhs); + _lhs = lhs; + this.AdjustWidth(assignmentSign); + _assignmentSign = assignmentSign; + this.AdjustWidth(rhs); + _rhs = rhs; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.AssignmentExpressionSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new AssignmentExpressionSyntaxNode(_lhs, _assignmentSign, _rhs, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -525,11 +804,28 @@ namespace Parser.Internal _catchBody = catchBody; } + internal CatchClauseSyntaxNode( + SyntaxToken catchKeyword, + SyntaxList catchBody, + TokenDiagnostic[] diagnostics) : base(TokenKind.CatchClause, diagnostics) + { + Slots = 2; + this.AdjustWidth(catchKeyword); + _catchKeyword = catchKeyword; + this.AdjustWidth(catchBody); + _catchBody = catchBody; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.CatchClauseSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new CatchClauseSyntaxNode(_catchKeyword, _catchBody, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -565,11 +861,34 @@ namespace Parser.Internal _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; + this.AdjustWidth(tryBody); + _tryBody = tryBody; + this.AdjustWidth(catchClause); + _catchClause = catchClause; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.TryCatchStatementSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new TryCatchStatementSyntaxNode(_tryKeyword, _tryBody, _catchClause, _endKeyword, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -595,11 +914,25 @@ namespace Parser.Internal _expression = expression; } + internal ExpressionStatementSyntaxNode( + ExpressionSyntaxNode expression, + TokenDiagnostic[] diagnostics) : base(TokenKind.ExpressionStatement, diagnostics) + { + Slots = 1; + this.AdjustWidth(expression); + _expression = expression; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ExpressionStatementSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ExpressionStatementSyntaxNode(_expression, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -622,11 +955,25 @@ namespace Parser.Internal _semicolon = semicolon; } + internal EmptyStatementSyntaxNode( + SyntaxToken semicolon, + TokenDiagnostic[] diagnostics) : base(TokenKind.EmptyStatement, diagnostics) + { + Slots = 1; + this.AdjustWidth(semicolon); + _semicolon = semicolon; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.EmptyStatementSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new EmptyStatementSyntaxNode(_semicolon, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -645,11 +992,22 @@ namespace Parser.Internal Slots = 0; } + internal EmptyExpressionSyntaxNode( + TokenDiagnostic[] diagnostics) : base(TokenKind.EmptyExpression, diagnostics) + { + Slots = 0; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.EmptyExpressionSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new EmptyExpressionSyntaxNode(diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -675,11 +1033,28 @@ namespace Parser.Internal _operand = operand; } + internal UnaryPrefixOperationExpressionSyntaxNode( + SyntaxToken operation, + ExpressionSyntaxNode operand, + TokenDiagnostic[] diagnostics) : base(TokenKind.UnaryPrefixOperationExpression, diagnostics) + { + Slots = 2; + this.AdjustWidth(operation); + _operation = operation; + this.AdjustWidth(operand); + _operand = operand; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.UnaryPrefixOperationExpressionSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new UnaryPrefixOperationExpressionSyntaxNode(_operation, _operand, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -703,11 +1078,25 @@ namespace Parser.Internal _nodes = nodes; } + internal CompoundNameSyntaxNode( + SyntaxList nodes, + TokenDiagnostic[] diagnostics) : base(TokenKind.CompoundName, diagnostics) + { + Slots = 1; + this.AdjustWidth(nodes); + _nodes = nodes; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.CompoundNameSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new CompoundNameSyntaxNode(_nodes, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -734,11 +1123,28 @@ namespace Parser.Internal _functionName = functionName; } + internal NamedFunctionHandleSyntaxNode( + SyntaxToken atSign, + CompoundNameSyntaxNode functionName, + TokenDiagnostic[] diagnostics) : base(TokenKind.NamedFunctionHandle, diagnostics) + { + Slots = 2; + this.AdjustWidth(atSign); + _atSign = atSign; + this.AdjustWidth(functionName); + _functionName = functionName; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.NamedFunctionHandleSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new NamedFunctionHandleSyntaxNode(_atSign, _functionName, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -770,11 +1176,31 @@ namespace Parser.Internal _body = body; } + internal LambdaSyntaxNode( + SyntaxToken atSign, + FunctionInputDescriptionSyntaxNode input, + ExpressionSyntaxNode body, + TokenDiagnostic[] diagnostics) : base(TokenKind.Lambda, diagnostics) + { + Slots = 3; + this.AdjustWidth(atSign); + _atSign = atSign; + this.AdjustWidth(input); + _input = input; + this.AdjustWidth(body); + _body = body; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.LambdaSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new LambdaSyntaxNode(_atSign, _input, _body, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -807,11 +1233,31 @@ namespace Parser.Internal _rhs = rhs; } + internal BinaryOperationExpressionSyntaxNode( + ExpressionSyntaxNode lhs, + SyntaxToken operation, + ExpressionSyntaxNode rhs, + TokenDiagnostic[] diagnostics) : base(TokenKind.BinaryOperation, diagnostics) + { + Slots = 3; + this.AdjustWidth(lhs); + _lhs = lhs; + this.AdjustWidth(operation); + _operation = operation; + this.AdjustWidth(rhs); + _rhs = rhs; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.BinaryOperationExpressionSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new BinaryOperationExpressionSyntaxNode(_lhs, _operation, _rhs, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -836,11 +1282,25 @@ namespace Parser.Internal _name = name; } + internal IdentifierNameSyntaxNode( + SyntaxToken name, + TokenDiagnostic[] diagnostics) : base(TokenKind.IdentifierName, diagnostics) + { + Slots = 1; + this.AdjustWidth(name); + _name = name; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.IdentifierNameSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new IdentifierNameSyntaxNode(_name, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -863,11 +1323,25 @@ namespace Parser.Internal _number = number; } + internal NumberLiteralSyntaxNode( + SyntaxToken number, + TokenDiagnostic[] diagnostics) : base(TokenKind.NumberLiteralExpression, diagnostics) + { + Slots = 1; + this.AdjustWidth(number); + _number = number; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.NumberLiteralSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new NumberLiteralSyntaxNode(_number, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -890,11 +1364,25 @@ namespace Parser.Internal _stringToken = stringToken; } + internal StringLiteralSyntaxNode( + SyntaxToken stringToken, + TokenDiagnostic[] diagnostics) : base(TokenKind.StringLiteralExpression, diagnostics) + { + Slots = 1; + this.AdjustWidth(stringToken); + _stringToken = stringToken; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.StringLiteralSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new StringLiteralSyntaxNode(_stringToken, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -917,11 +1405,25 @@ namespace Parser.Internal _stringToken = stringToken; } + internal DoubleQuotedStringLiteralSyntaxNode( + SyntaxToken stringToken, + TokenDiagnostic[] diagnostics) : base(TokenKind.DoubleQuotedStringLiteralExpression, diagnostics) + { + Slots = 1; + this.AdjustWidth(stringToken); + _stringToken = stringToken; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.DoubleQuotedStringLiteralSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new DoubleQuotedStringLiteralSyntaxNode(_stringToken, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -944,11 +1446,25 @@ namespace Parser.Internal _stringToken = stringToken; } + internal UnquotedStringLiteralSyntaxNode( + SyntaxToken stringToken, + TokenDiagnostic[] diagnostics) : base(TokenKind.UnquotedStringLiteralExpression, diagnostics) + { + Slots = 1; + this.AdjustWidth(stringToken); + _stringToken = stringToken; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.UnquotedStringLiteralSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new UnquotedStringLiteralSyntaxNode(_stringToken, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -979,11 +1495,31 @@ namespace Parser.Internal _closingSquareBracket = closingSquareBracket; } + internal ArrayLiteralExpressionSyntaxNode( + SyntaxToken openingSquareBracket, + SyntaxList nodes, + SyntaxToken closingSquareBracket, + TokenDiagnostic[] diagnostics) : base(TokenKind.ArrayLiteralExpression, diagnostics) + { + Slots = 3; + this.AdjustWidth(openingSquareBracket); + _openingSquareBracket = openingSquareBracket; + this.AdjustWidth(nodes); + _nodes = nodes; + this.AdjustWidth(closingSquareBracket); + _closingSquareBracket = closingSquareBracket; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ArrayLiteralExpressionSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ArrayLiteralExpressionSyntaxNode(_openingSquareBracket, _nodes, _closingSquareBracket, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1016,11 +1552,31 @@ namespace Parser.Internal _closingBrace = closingBrace; } + internal CellArrayLiteralExpressionSyntaxNode( + SyntaxToken openingBrace, + SyntaxList nodes, + SyntaxToken closingBrace, + TokenDiagnostic[] diagnostics) : base(TokenKind.CellArrayLiteralExpression, diagnostics) + { + Slots = 3; + this.AdjustWidth(openingBrace); + _openingBrace = openingBrace; + this.AdjustWidth(nodes); + _nodes = nodes; + this.AdjustWidth(closingBrace); + _closingBrace = closingBrace; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.CellArrayLiteralExpressionSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new CellArrayLiteralExpressionSyntaxNode(_openingBrace, _nodes, _closingBrace, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1053,11 +1609,31 @@ namespace Parser.Internal _closingBracket = closingBracket; } + internal ParenthesizedExpressionSyntaxNode( + SyntaxToken openingBracket, + ExpressionSyntaxNode expression, + SyntaxToken closingBracket, + TokenDiagnostic[] diagnostics) : base(TokenKind.ParenthesizedExpression, diagnostics) + { + Slots = 3; + this.AdjustWidth(openingBracket); + _openingBracket = openingBracket; + this.AdjustWidth(expression); + _expression = expression; + this.AdjustWidth(closingBracket); + _closingBracket = closingBracket; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ParenthesizedExpressionSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ParenthesizedExpressionSyntaxNode(_openingBracket, _expression, _closingBracket, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1094,11 +1670,34 @@ namespace Parser.Internal _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; + this.AdjustWidth(openingBrace); + _openingBrace = openingBrace; + this.AdjustWidth(nodes); + _nodes = nodes; + this.AdjustWidth(closingBrace); + _closingBrace = closingBrace; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.CellArrayElementAccessExpressionSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new CellArrayElementAccessExpressionSyntaxNode(_expression, _openingBrace, _nodes, _closingBrace, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1136,11 +1735,34 @@ namespace Parser.Internal _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; + this.AdjustWidth(openingBracket); + _openingBracket = openingBracket; + this.AdjustWidth(nodes); + _nodes = nodes; + this.AdjustWidth(closingBracket); + _closingBracket = closingBracket; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.FunctionCallExpressionSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new FunctionCallExpressionSyntaxNode(_functionName, _openingBracket, _nodes, _closingBracket, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1174,11 +1796,31 @@ namespace Parser.Internal _rightOperand = rightOperand; } + internal MemberAccessSyntaxNode( + SyntaxNode leftOperand, + SyntaxToken dot, + SyntaxNode rightOperand, + TokenDiagnostic[] diagnostics) : base(TokenKind.MemberAccess, diagnostics) + { + Slots = 3; + this.AdjustWidth(leftOperand); + _leftOperand = leftOperand; + this.AdjustWidth(dot); + _dot = dot; + this.AdjustWidth(rightOperand); + _rightOperand = rightOperand; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.MemberAccessSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new MemberAccessSyntaxNode(_leftOperand, _dot, _rightOperand, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1207,11 +1849,28 @@ namespace Parser.Internal _operation = operation; } + internal UnaryPostixOperationExpressionSyntaxNode( + ExpressionSyntaxNode operand, + SyntaxToken operation, + TokenDiagnostic[] diagnostics) : base(TokenKind.UnaryPostfixOperationExpression, diagnostics) + { + Slots = 2; + this.AdjustWidth(operand); + _operand = operand; + this.AdjustWidth(operation); + _operation = operation; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.UnaryPostixOperationExpressionSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new UnaryPostixOperationExpressionSyntaxNode(_operand, _operation, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1243,11 +1902,31 @@ namespace Parser.Internal _closingBracket = closingBracket; } + internal IndirectMemberAccessSyntaxNode( + SyntaxToken openingBracket, + ExpressionSyntaxNode expression, + SyntaxToken closingBracket, + TokenDiagnostic[] diagnostics) : base(TokenKind.IndirectMemberAccess, diagnostics) + { + Slots = 3; + this.AdjustWidth(openingBracket); + _openingBracket = openingBracket; + this.AdjustWidth(expression); + _expression = expression; + this.AdjustWidth(closingBracket); + _closingBracket = closingBracket; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.IndirectMemberAccessSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new IndirectMemberAccessSyntaxNode(_openingBracket, _expression, _closingBracket, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1276,11 +1955,28 @@ namespace Parser.Internal _arguments = arguments; } + internal CommandExpressionSyntaxNode( + IdentifierNameSyntaxNode commandName, + SyntaxList arguments, + TokenDiagnostic[] diagnostics) : base(TokenKind.Command, diagnostics) + { + Slots = 2; + this.AdjustWidth(commandName); + _commandName = commandName; + this.AdjustWidth(arguments); + _arguments = arguments; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.CommandExpressionSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new CommandExpressionSyntaxNode(_commandName, _arguments, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1312,11 +2008,31 @@ namespace Parser.Internal _baseClassNameAndArguments = baseClassNameAndArguments; } + internal BaseClassInvokationSyntaxNode( + ExpressionSyntaxNode methodName, + SyntaxToken atSign, + ExpressionSyntaxNode baseClassNameAndArguments, + TokenDiagnostic[] diagnostics) : base(TokenKind.ClassInvokation, diagnostics) + { + Slots = 3; + this.AdjustWidth(methodName); + _methodName = methodName; + this.AdjustWidth(atSign); + _atSign = atSign; + this.AdjustWidth(baseClassNameAndArguments); + _baseClassNameAndArguments = baseClassNameAndArguments; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.BaseClassInvokationSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new BaseClassInvokationSyntaxNode(_methodName, _atSign, _baseClassNameAndArguments, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1345,11 +2061,28 @@ namespace Parser.Internal _value = value; } + internal AttributeAssignmentSyntaxNode( + SyntaxToken assignmentSign, + ExpressionSyntaxNode value, + TokenDiagnostic[] diagnostics) : base(TokenKind.AttributeAssignment, diagnostics) + { + Slots = 2; + this.AdjustWidth(assignmentSign); + _assignmentSign = assignmentSign; + this.AdjustWidth(value); + _value = value; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.AttributeAssignmentSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new AttributeAssignmentSyntaxNode(_assignmentSign, _value, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1377,11 +2110,28 @@ namespace Parser.Internal _assignment = assignment; } + internal AttributeSyntaxNode( + IdentifierNameSyntaxNode name, + AttributeAssignmentSyntaxNode? assignment, + TokenDiagnostic[] diagnostics) : base(TokenKind.Attribute, diagnostics) + { + Slots = 2; + this.AdjustWidth(name); + _name = name; + this.AdjustWidth(assignment); + _assignment = assignment; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.AttributeSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new AttributeSyntaxNode(_name, _assignment, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1413,11 +2163,31 @@ namespace Parser.Internal _closingBracket = closingBracket; } + internal AttributeListSyntaxNode( + SyntaxToken openingBracket, + SyntaxList nodes, + SyntaxToken closingBracket, + TokenDiagnostic[] diagnostics) : base(TokenKind.AttributeList, diagnostics) + { + Slots = 3; + this.AdjustWidth(openingBracket); + _openingBracket = openingBracket; + this.AdjustWidth(nodes); + _nodes = nodes; + this.AdjustWidth(closingBracket); + _closingBracket = closingBracket; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.AttributeListSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new AttributeListSyntaxNode(_openingBracket, _nodes, _closingBracket, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1466,11 +2236,43 @@ namespace Parser.Internal _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; + 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 override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.MethodDefinitionSyntaxNode(parent, this, position); } + 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) @@ -1507,11 +2309,31 @@ namespace Parser.Internal _inputDescription = inputDescription; } + internal AbstractMethodDeclarationSyntaxNode( + FunctionOutputDescriptionSyntaxNode? outputDescription, + CompoundNameSyntaxNode name, + FunctionInputDescriptionSyntaxNode? inputDescription, + TokenDiagnostic[] diagnostics) : base(TokenKind.AbstractMethodDeclaration, diagnostics) + { + Slots = 3; + this.AdjustWidth(outputDescription); + _outputDescription = outputDescription; + this.AdjustWidth(name); + _name = name; + this.AdjustWidth(inputDescription); + _inputDescription = inputDescription; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.AbstractMethodDeclarationSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new AbstractMethodDeclarationSyntaxNode(_outputDescription, _name, _inputDescription, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1548,11 +2370,34 @@ namespace Parser.Internal _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; + this.AdjustWidth(attributes); + _attributes = attributes; + this.AdjustWidth(methods); + _methods = methods; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.MethodsListSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new MethodsListSyntaxNode(_methodsKeyword, _attributes, _methods, _endKeyword, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1590,11 +2435,34 @@ namespace Parser.Internal _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; + this.AdjustWidth(attributes); + _attributes = attributes; + this.AdjustWidth(properties); + _properties = properties; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.PropertiesListSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new PropertiesListSyntaxNode(_propertiesKeyword, _attributes, _properties, _endKeyword, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1624,11 +2492,28 @@ namespace Parser.Internal _baseClasses = baseClasses; } + internal BaseClassListSyntaxNode( + SyntaxToken lessSign, + SyntaxList baseClasses, + TokenDiagnostic[] diagnostics) : base(TokenKind.BaseClassList, diagnostics) + { + Slots = 2; + this.AdjustWidth(lessSign); + _lessSign = lessSign; + this.AdjustWidth(baseClasses); + _baseClasses = baseClasses; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.BaseClassListSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new BaseClassListSyntaxNode(_lessSign, _baseClasses, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1672,11 +2557,40 @@ namespace Parser.Internal _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; + 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 override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ClassDeclarationSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new ClassDeclarationSyntaxNode(_classdefKeyword, _attributes, _className, _baseClassList, _nodes, _endKeyword, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1712,11 +2626,31 @@ namespace Parser.Internal _closingBracket = closingBracket; } + internal EnumerationItemValueSyntaxNode( + SyntaxToken openingBracket, + SyntaxList values, + SyntaxToken closingBracket, + TokenDiagnostic[] diagnostics) : base(TokenKind.EnumerationItemValue, diagnostics) + { + Slots = 3; + this.AdjustWidth(openingBracket); + _openingBracket = openingBracket; + this.AdjustWidth(values); + _values = values; + this.AdjustWidth(closingBracket); + _closingBracket = closingBracket; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.EnumerationItemValueSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new EnumerationItemValueSyntaxNode(_openingBracket, _values, _closingBracket, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1749,11 +2683,31 @@ namespace Parser.Internal _commas = commas; } + internal EnumerationItemSyntaxNode( + IdentifierNameSyntaxNode name, + EnumerationItemValueSyntaxNode? values, + SyntaxList commas, + TokenDiagnostic[] diagnostics) : base(TokenKind.EnumerationItem, diagnostics) + { + Slots = 3; + this.AdjustWidth(name); + _name = name; + this.AdjustWidth(values); + _values = values; + this.AdjustWidth(commas); + _commas = commas; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.EnumerationItemSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new EnumerationItemSyntaxNode(_name, _values, _commas, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1790,11 +2744,34 @@ namespace Parser.Internal _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; + this.AdjustWidth(attributes); + _attributes = attributes; + this.AdjustWidth(items); + _items = items; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.EnumerationListSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new EnumerationListSyntaxNode(_enumerationKeyword, _attributes, _items, _endKeyword, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1832,11 +2809,34 @@ namespace Parser.Internal _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; + this.AdjustWidth(attributes); + _attributes = attributes; + this.AdjustWidth(events); + _events = events; + this.AdjustWidth(endKeyword); + _endKeyword = endKeyword; + } + internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.EventsListSyntaxNode(parent, this, position); } + public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) + { + return new EventsListSyntaxNode(_eventsKeyword, _attributes, _events, _endKeyword, diagnostics); + } + public override GreenNode? GetSlot(int i) { switch (i) @@ -1862,11 +2862,25 @@ namespace Parser.Internal _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) diff --git a/Parser/Internal/SyntaxNode.cs b/Parser/Internal/SyntaxNode.cs index 2223e89..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,6 +95,10 @@ namespace Parser.Internal protected MethodDeclarationSyntaxNode(TokenKind kind) : base(kind) { } + + protected MethodDeclarationSyntaxNode(TokenKind kind, TokenDiagnostic[] diagnostics) : base(kind, diagnostics) + { + } } internal class RootSyntaxNode : SyntaxNode @@ -91,6 +112,13 @@ namespace Parser.Internal _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) @@ -100,6 +128,11 @@ namespace Parser.Internal } } + 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 3a79599..4c5ff63 100644 --- a/Parser/Internal/SyntaxToken.cs +++ b/Parser/Internal/SyntaxToken.cs @@ -12,7 +12,7 @@ namespace Parser.Internal 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,15 +284,33 @@ 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 => s_EmptySyntaxTriviaList; diff --git a/Parser/Internal/SyntaxTrivia.cs b/Parser/Internal/SyntaxTrivia.cs index 0ab0377..277bc5a 100644 --- a/Parser/Internal/SyntaxTrivia.cs +++ b/Parser/Internal/SyntaxTrivia.cs @@ -14,6 +14,11 @@ 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; @@ -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/Parser.csproj b/Parser/Parser.csproj index 0922761..122db84 100644 --- a/Parser/Parser.csproj +++ b/Parser/Parser.csproj @@ -1,6 +1,6 @@  - netstandard2.0 + netcoreapp3.0 8.0 enable diff --git a/Parser/SyntaxNode.cs b/Parser/SyntaxNode.cs index 117e1e2..54a8d74 100644 --- a/Parser/SyntaxNode.cs +++ b/Parser/SyntaxNode.cs @@ -96,6 +96,67 @@ 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 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; + } + } + + public class MissingTokenSyntaxDiagnostic : SyntaxDiagnostic + { + public TokenKind Kind { get; } + + internal MissingTokenSyntaxDiagnostic(int position, TokenKind tokenKind) + : base(position) + { + Kind = tokenKind; + } } public abstract class StatementSyntaxNode : SyntaxNode 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 5b68a82..da536f2 100644 --- a/SyntaxGenerator/GenerateSyntax.cs +++ b/SyntaxGenerator/GenerateSyntax.cs @@ -78,8 +78,8 @@ 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( ",", @@ -94,6 +94,27 @@ namespace SyntaxGenerator 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) { var arguments = "SyntaxNode parent, Internal.GreenNode green, int position"; @@ -102,6 +123,18 @@ 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"; @@ -156,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"; }