From 652bd92f0179deb817502594c614b7f61b11fa97 Mon Sep 17 00:00:00 2001 From: Alexander Luzgarev Date: Wed, 15 Jul 2020 10:22:16 +0200 Subject: [PATCH] Add BoundTreeRewriter --- Parser/Binding/Binder.cs | 20 +- Parser/Binding/BoundBinaryOperator.cs | 48 +++ Parser/Binding/BoundBinaryOperatorKind.cs | 29 ++ Parser/Binding/BoundNode.cs | 13 + Parser/Binding/BoundNodeKind.cs | 52 +++ Parser/Binding/BoundRoot.cs | 154 +------- Parser/Binding/BoundTreeRewriter.cs | 396 +++++++++++++++++++++ Parser/Internal/SyntaxFactory.Generated.cs | 18 +- Parser/Internal/SyntaxNode.Generated.cs | 54 +-- Parser/Parser.csproj | 1 + Parser/SyntaxDefinition.xml | 18 +- Parser/SyntaxNode.Generated.cs | 36 +- 12 files changed, 622 insertions(+), 217 deletions(-) create mode 100644 Parser/Binding/BoundBinaryOperator.cs create mode 100644 Parser/Binding/BoundBinaryOperatorKind.cs create mode 100644 Parser/Binding/BoundNode.cs create mode 100644 Parser/Binding/BoundNodeKind.cs create mode 100644 Parser/Binding/BoundTreeRewriter.cs diff --git a/Parser/Binding/Binder.cs b/Parser/Binding/Binder.cs index 820fc76..2dd9d83 100644 --- a/Parser/Binding/Binder.cs +++ b/Parser/Binding/Binder.cs @@ -70,14 +70,14 @@ namespace Parser.Binding private BoundIfStatement BindIfStatement(IfStatementSyntaxNode node) { var condition = BindExpression(node.Condition); - var body = BindBlockStatement(node.Body); - var elseIfClauses = node.ElseifClauses + var body = BindStatement(node.Body); + var elseifClauses = node.ElseifClauses .Where(n => n.IsNode) .Select(n => (ElseifClause)n.AsNode()!); - var builder = ImmutableArray.CreateBuilder(); - foreach (var elseIfClause in elseIfClauses) + var builder = ImmutableArray.CreateBuilder(); + foreach (var elseifClause in elseifClauses) { - var clause = BindElseIfClause(elseIfClause); + var clause = BindElseifClause(elseifClause); builder.Add(clause); } var maybeElseClause = node.ElseClause switch @@ -86,12 +86,12 @@ namespace Parser.Binding _ => null, }; - return new BoundIfStatement(node, condition, body, elseIfClauses, maybeElseClause); + return new BoundIfStatement(node, condition, body, builder.ToImmutable(), maybeElseClause); } private BoundElseClause BindElseClause(ElseClause node) { - var body = BindBlockStatement(node.Body); + var body = BindStatement(node.Body); return new BoundElseClause(node, body); } @@ -127,11 +127,11 @@ namespace Parser.Binding return builder.ToImmutable(); } - private BoundElseIfClause BindElseIfClause(ElseifClause node) + private BoundElseifClause BindElseifClause(ElseifClause node) { var condition = BindExpression(node.Condition); - var body = BindBlockStatement(node.Body); - return new BoundElseIfClause(node, condition, body); + var body = BindStatement(node.Body); + return new BoundElseifClause(node, condition, body); } private BoundFunctionDeclaration BindFunctionDeclaration(FunctionDeclarationSyntaxNode node) diff --git a/Parser/Binding/BoundBinaryOperator.cs b/Parser/Binding/BoundBinaryOperator.cs new file mode 100644 index 0000000..73dc880 --- /dev/null +++ b/Parser/Binding/BoundBinaryOperator.cs @@ -0,0 +1,48 @@ +using System.Linq; + +namespace Parser.Binding +{ + public class BoundBinaryOperator + { + private static BoundBinaryOperator[] _operators = + { + new BoundBinaryOperator(TokenKind.EqualsToken, BoundBinaryOperatorKind.Equals), + new BoundBinaryOperator(TokenKind.PipePipeToken, BoundBinaryOperatorKind.PipePipe), + new BoundBinaryOperator(TokenKind.AmpersandAmpersandToken, BoundBinaryOperatorKind.AmpersandAmpersand), + new BoundBinaryOperator(TokenKind.PipeToken, BoundBinaryOperatorKind.Pipe), + new BoundBinaryOperator(TokenKind.AmpersandToken, BoundBinaryOperatorKind.Ampersand), + new BoundBinaryOperator(TokenKind.LessToken, BoundBinaryOperatorKind.Less), + new BoundBinaryOperator(TokenKind.LessOrEqualsToken, BoundBinaryOperatorKind.LessOrEquals), + new BoundBinaryOperator(TokenKind.GreaterToken, BoundBinaryOperatorKind.Greater), + new BoundBinaryOperator(TokenKind.GreaterOrEqualsToken, BoundBinaryOperatorKind.GreaterOrEquals), + new BoundBinaryOperator(TokenKind.EqualsEqualsToken, BoundBinaryOperatorKind.EqualsEquals), + new BoundBinaryOperator(TokenKind.TildeEqualsToken, BoundBinaryOperatorKind.TildeEquals), + new BoundBinaryOperator(TokenKind.ColonToken, BoundBinaryOperatorKind.Colon), + new BoundBinaryOperator(TokenKind.PlusToken, BoundBinaryOperatorKind.Plus), + new BoundBinaryOperator(TokenKind.MinusToken, BoundBinaryOperatorKind.Minus), + new BoundBinaryOperator(TokenKind.StarToken, BoundBinaryOperatorKind.Star), + new BoundBinaryOperator(TokenKind.DotStarToken, BoundBinaryOperatorKind.DotStar), + new BoundBinaryOperator(TokenKind.SlashToken, BoundBinaryOperatorKind.Slash), + new BoundBinaryOperator(TokenKind.DotSlashToken, BoundBinaryOperatorKind.DotSlash), + new BoundBinaryOperator(TokenKind.BackslashToken, BoundBinaryOperatorKind.Backslash), + new BoundBinaryOperator(TokenKind.DotBackslashToken, BoundBinaryOperatorKind.DotBackslash), + new BoundBinaryOperator(TokenKind.TildeToken, BoundBinaryOperatorKind.Tilde), + new BoundBinaryOperator(TokenKind.CaretToken, BoundBinaryOperatorKind.Caret), + new BoundBinaryOperator(TokenKind.DotCaretToken, BoundBinaryOperatorKind.DotCaret), + }; + + public BoundBinaryOperator(TokenKind syntaxKind, BoundBinaryOperatorKind kind) + { + SyntaxKind = syntaxKind; + Kind = kind; + } + + public TokenKind SyntaxKind { get; } + public BoundBinaryOperatorKind Kind { get; } + + internal static BoundBinaryOperator? GetOperator(TokenKind kind) + { + return _operators.FirstOrDefault(op => op.SyntaxKind == kind); + } + } +} diff --git a/Parser/Binding/BoundBinaryOperatorKind.cs b/Parser/Binding/BoundBinaryOperatorKind.cs new file mode 100644 index 0000000..cf43bf7 --- /dev/null +++ b/Parser/Binding/BoundBinaryOperatorKind.cs @@ -0,0 +1,29 @@ +namespace Parser.Binding +{ + public enum BoundBinaryOperatorKind + { + Equals, + PipePipe, + AmpersandAmpersand, + Pipe, + Ampersand, + Less, + LessOrEquals, + Greater, + GreaterOrEquals, + EqualsEquals, + TildeEquals, + Colon, + Plus, + Minus, + Star, + DotStar, + Slash, + DotSlash, + Backslash, + DotBackslash, + Tilde, + Caret, + DotCaret, + } +} diff --git a/Parser/Binding/BoundNode.cs b/Parser/Binding/BoundNode.cs new file mode 100644 index 0000000..5f3ac1a --- /dev/null +++ b/Parser/Binding/BoundNode.cs @@ -0,0 +1,13 @@ +namespace Parser.Binding +{ + public abstract class BoundNode + { + public BoundNode(SyntaxNode syntax) + { + Syntax = syntax; + } + + public SyntaxNode Syntax { get; } + public abstract BoundNodeKind Kind { get; } + } +} diff --git a/Parser/Binding/BoundNodeKind.cs b/Parser/Binding/BoundNodeKind.cs new file mode 100644 index 0000000..d75402f --- /dev/null +++ b/Parser/Binding/BoundNodeKind.cs @@ -0,0 +1,52 @@ +namespace Parser.Binding +{ + public enum BoundNodeKind + { + Root, + File, + + // Statements + + AbstractMethodDeclaration, + BlockStatement, + ClassDeclaration, + ConcreteMethodDeclaration, + EmptyStatement, + ExpressionStatement, + ForStatement, + FunctionDeclaration, + IfStatement, + SwitchStatement, + TryCatchStatement, + WhileStatement, + + // Expressions + + ArrayLiteralExpression, + AssignmentExpression, + BinaryOperationExpression, + CellArrayElementAccessExpression, + CellArrayLiteralExpression, + ClassInvokationExpression, + CommandExpression, + CompoundNameExpression, + DoubleQuotedStringLiteralExpression, + EmptyExpression, + FunctionCallExpression, + IdentifierNameExpression, + IndirectMemberAccessExpression, + LambdaExpression, + MemberAccessExpression, + NamedFunctionHandleExpression, + NumberLiteralExpression, + ParenthesizedExpression, + StringLiteralExpression, + UnaryPrefixOperationExpression, + UnaryPostfixOperationExpression, + UnquotedStringLiteralExpression, + + // Parts + ElseIfClause, + ElseClause + } +} diff --git a/Parser/Binding/BoundRoot.cs b/Parser/Binding/BoundRoot.cs index 2b7761f..6094363 100644 --- a/Parser/Binding/BoundRoot.cs +++ b/Parser/Binding/BoundRoot.cs @@ -1,98 +1,8 @@ -using System; -using System.Collections.Generic; +using System.Collections.Generic; using System.Collections.Immutable; -using System.Linq; namespace Parser.Binding { - public enum BoundNodeKind - { - Root, - File, - - // Statements - - AbstractMethodDeclaration, - BlockStatement, - ClassDeclaration, - ConcreteMethodDeclaration, - EmptyStatement, - ExpressionStatement, - ForStatement, - FunctionDeclaration, - IfStatement, - SwitchStatement, - TryCatchStatement, - WhileStatement, - - // Expressions - - ArrayLiteralExpression, - AssignmentExpression, - BinaryOperationExpression, - CellArrayElementAccessExpression, - CellArrayLiteralExpression, - ClassInvokationExpression, - CommandExpression, - CompoundNameExpression, - DoubleQuotedStringLiteralExpression, - EmptyExpression, - FunctionCallExpression, - IdentifierNameExpression, - IndirectMemberAccessExpression, - LambdaExpression, - MemberAccessExpression, - NamedFunctionHandleExpression, - NumberLiteralExpression, - ParenthesizedExpression, - StringLiteralExpression, - UnaryPrefixOperationExpression, - UnaryPostfixOperationExpression, - UnquotedStringLiteralExpression, - - // Parts - ElseIfClause, - ElseClause - } - - public enum BoundBinaryOperatorKind - { - Equals, - PipePipe, - AmpersandAmpersand, - Pipe, - Ampersand, - Less, - LessOrEquals, - Greater, - GreaterOrEquals, - EqualsEquals, - TildeEquals, - Colon, - Plus, - Minus, - Star, - DotStar, - Slash, - DotSlash, - Backslash, - DotBackslash, - Tilde, - Caret, - DotCaret, - } - - public abstract class BoundNode - { - public BoundNode(SyntaxNode syntax) - { - Syntax = syntax; - } - - public SyntaxNode Syntax { get; } - public abstract BoundNodeKind Kind { get; } - } - public class BoundRoot : BoundNode { public BoundRoot(SyntaxNode syntax, BoundFile file) @@ -223,18 +133,18 @@ namespace Parser.Binding public class BoundIfStatement : BoundStatement { - public BoundIfStatement(SyntaxNode syntax, BoundExpression condition, BoundBlockStatement body, IEnumerable elseIfClauses, BoundElseClause? elseClause) + public BoundIfStatement(SyntaxNode syntax, BoundExpression condition, BoundStatement body, ImmutableArray elseifClauses, BoundElseClause? elseClause) : base(syntax) { Condition = condition; Body = body; - ElseIfClauses = elseIfClauses; + ElseifClauses = elseifClauses; ElseClause = elseClause; } public BoundExpression Condition { get; } - public BoundBlockStatement Body { get; } - public IEnumerable ElseIfClauses { get; } + public BoundStatement Body { get; } + public ImmutableArray ElseifClauses { get; } public BoundElseClause? ElseClause { get; } public override BoundNodeKind Kind => BoundNodeKind.IfStatement; @@ -523,9 +433,9 @@ namespace Parser.Binding public override BoundNodeKind Kind => BoundNodeKind.UnquotedStringLiteralExpression; } - public class BoundElseIfClause : BoundNode + public class BoundElseifClause : BoundNode { - public BoundElseIfClause(SyntaxNode syntax, BoundExpression condition, BoundBlockStatement body) + public BoundElseifClause(SyntaxNode syntax, BoundExpression condition, BoundStatement body) : base(syntax) { Condition = condition; @@ -533,63 +443,19 @@ namespace Parser.Binding } public BoundExpression Condition { get; } - public BoundBlockStatement Body { get; } + public BoundStatement Body { get; } public override BoundNodeKind Kind => BoundNodeKind.ElseIfClause; } public class BoundElseClause : BoundNode { - public BoundElseClause(SyntaxNode syntax, BoundBlockStatement body) + public BoundElseClause(SyntaxNode syntax, BoundStatement body) : base(syntax) { Body = body; } - public BoundBlockStatement Body { get; } + public BoundStatement Body { get; } public override BoundNodeKind Kind => BoundNodeKind.ElseClause; } - - public class BoundBinaryOperator - { - private static BoundBinaryOperator[] _operators = - { - new BoundBinaryOperator(TokenKind.EqualsToken, BoundBinaryOperatorKind.Equals), - new BoundBinaryOperator(TokenKind.PipePipeToken, BoundBinaryOperatorKind.PipePipe), - new BoundBinaryOperator(TokenKind.AmpersandAmpersandToken, BoundBinaryOperatorKind.AmpersandAmpersand), - new BoundBinaryOperator(TokenKind.PipeToken, BoundBinaryOperatorKind.Pipe), - new BoundBinaryOperator(TokenKind.AmpersandToken, BoundBinaryOperatorKind.Ampersand), - new BoundBinaryOperator(TokenKind.LessToken, BoundBinaryOperatorKind.Less), - new BoundBinaryOperator(TokenKind.LessOrEqualsToken, BoundBinaryOperatorKind.LessOrEquals), - new BoundBinaryOperator(TokenKind.GreaterToken, BoundBinaryOperatorKind.Greater), - new BoundBinaryOperator(TokenKind.GreaterOrEqualsToken, BoundBinaryOperatorKind.GreaterOrEquals), - new BoundBinaryOperator(TokenKind.EqualsEqualsToken, BoundBinaryOperatorKind.EqualsEquals), - new BoundBinaryOperator(TokenKind.TildeEqualsToken, BoundBinaryOperatorKind.TildeEquals), - new BoundBinaryOperator(TokenKind.ColonToken, BoundBinaryOperatorKind.Colon), - new BoundBinaryOperator(TokenKind.PlusToken, BoundBinaryOperatorKind.Plus), - new BoundBinaryOperator(TokenKind.MinusToken, BoundBinaryOperatorKind.Minus), - new BoundBinaryOperator(TokenKind.StarToken, BoundBinaryOperatorKind.Star), - new BoundBinaryOperator(TokenKind.DotStarToken, BoundBinaryOperatorKind.DotStar), - new BoundBinaryOperator(TokenKind.SlashToken, BoundBinaryOperatorKind.Slash), - new BoundBinaryOperator(TokenKind.DotSlashToken, BoundBinaryOperatorKind.DotSlash), - new BoundBinaryOperator(TokenKind.BackslashToken, BoundBinaryOperatorKind.Backslash), - new BoundBinaryOperator(TokenKind.DotBackslashToken, BoundBinaryOperatorKind.DotBackslash), - new BoundBinaryOperator(TokenKind.TildeToken, BoundBinaryOperatorKind.Tilde), - new BoundBinaryOperator(TokenKind.CaretToken, BoundBinaryOperatorKind.Caret), - new BoundBinaryOperator(TokenKind.DotCaretToken, BoundBinaryOperatorKind.DotCaret), - }; - - public BoundBinaryOperator(TokenKind syntaxKind, BoundBinaryOperatorKind kind) - { - SyntaxKind = syntaxKind; - Kind = kind; - } - - public TokenKind SyntaxKind { get; } - public BoundBinaryOperatorKind Kind { get; } - - internal static BoundBinaryOperator? GetOperator(TokenKind kind) - { - return _operators.FirstOrDefault(op => op.SyntaxKind == kind); - } - } } diff --git a/Parser/Binding/BoundTreeRewriter.cs b/Parser/Binding/BoundTreeRewriter.cs new file mode 100644 index 0000000..025dca8 --- /dev/null +++ b/Parser/Binding/BoundTreeRewriter.cs @@ -0,0 +1,396 @@ +using System; +using System.Collections.Immutable; + +namespace Parser.Binding +{ + public abstract class BoundTreeRewriter + { + public virtual BoundStatement RewriteStatement(BoundStatement node) + { + return node.Kind switch + { + BoundNodeKind.AbstractMethodDeclaration => + RewriteAbstractMethodDeclaration((BoundAbstractMethodDeclaration)node), + BoundNodeKind.BlockStatement => + RewriteBlockStatement((BoundBlockStatement)node), + BoundNodeKind.ClassDeclaration => + RewriteClassDeclaration((BoundClassDeclaration)node), + BoundNodeKind.ConcreteMethodDeclaration => + RewriteConcreteMethodDeclaration((BoundConcreteMethodDeclaration)node), + BoundNodeKind.EmptyStatement => + RewriteEmptyStatement((BoundEmptyStatement)node), + BoundNodeKind.ExpressionStatement => + RewriteExpressionStatement((BoundExpressionStatement)node), + BoundNodeKind.ForStatement => + RewriteForStatement((BoundForStatement)node), + BoundNodeKind.FunctionDeclaration => + RewriteFunctionDeclaration((BoundFunctionDeclaration)node), + BoundNodeKind.IfStatement => + RewriteIfStatement((BoundIfStatement)node), + BoundNodeKind.SwitchStatement => + RewriteSwitchStatement((BoundSwitchStatement)node), + BoundNodeKind.TryCatchStatement => + RewriteTryCatchStatement((BoundTryCatchStatement)node), + BoundNodeKind.WhileStatement => + RewriteWhileStatement((BoundWhileStatement)node), + _ => + throw new Exception($"Invalid statement kind {node.Kind}."), + }; + } + + public virtual BoundStatement RewriteWhileStatement(BoundWhileStatement node) + { + throw new NotImplementedException(); + } + + public virtual BoundStatement RewriteTryCatchStatement(BoundTryCatchStatement node) + { + throw new NotImplementedException(); + } + + public virtual BoundStatement RewriteSwitchStatement(BoundSwitchStatement node) + { + throw new NotImplementedException(); + } + + public virtual BoundStatement RewriteIfStatement(BoundIfStatement node) + { + var condition = RewriteExpression(node.Condition); + var body = RewriteStatement(node.Body); + ImmutableArray.Builder? builder = null; + for (var i = 0; i < node.ElseifClauses.Length; i++) + { + var oldClause = node.ElseifClauses[i]; + var newClause = RewriteElseifClause(oldClause); + if (oldClause != newClause && builder is null) + { + builder = ImmutableArray.CreateBuilder(node.ElseifClauses.Length); + for (var j = 0; j < i; i++) + { + builder.Add(node.ElseifClauses[j]); + } + } + if (builder is not null) + { + builder.Add(newClause); + } + + } + + var elseIfClauses = builder is null ? node.ElseifClauses : builder.MoveToImmutable(); + var elseClause = node.ElseClause is null ? null : RewriteElseifClause(node.ElseClause); + if (condition == node.Condition && + body == node.Body && + elseIfClauses == node.ElseifClauses && + elseClause == node.ElseClause ) + { + return node; + } + + return new BoundIfStatement(node.Syntax, condition, body, elseIfClauses, elseClause); + } + + public virtual BoundElseClause RewriteElseifClause(BoundElseClause node) + { + var body = RewriteStatement(node.Body); + if (body == node.Body) + { + return node; + } + + return new BoundElseClause(node.Syntax, body); + } + + public virtual BoundElseifClause RewriteElseifClause(BoundElseifClause node) + { + var condition = RewriteExpression(node.Condition); + var body = RewriteStatement(node.Body); + if (condition == node.Condition && body == node.Body) + { + return node; + } + + return new BoundElseifClause(node.Syntax, condition, body); + } + + public virtual BoundStatement RewriteFunctionDeclaration(BoundFunctionDeclaration node) + { + throw new NotImplementedException(); + } + + public virtual BoundStatement RewriteForStatement(BoundForStatement node) + { + throw new NotImplementedException(); + } + + public virtual BoundStatement RewriteExpressionStatement(BoundExpressionStatement node) + { + var expression = RewriteExpression(node.Expression); + if (expression == node.Expression) + { + return node; + } + + return new BoundExpressionStatement(node.Syntax, expression); + } + + public virtual BoundStatement RewriteEmptyStatement(BoundEmptyStatement node) + { + throw new NotImplementedException(); + } + + public virtual BoundStatement RewriteConcreteMethodDeclaration(BoundConcreteMethodDeclaration node) + { + throw new NotImplementedException(); + } + + public virtual BoundStatement RewriteClassDeclaration(BoundClassDeclaration node) + { + throw new NotImplementedException(); + } + + public virtual BoundStatement RewriteBlockStatement(BoundBlockStatement node) + { + ImmutableArray.Builder? builder = null; + for (var i = 0; i < node.Statements.Length; i++) + { + var oldStatement = node.Statements[i]; + var newStatement = RewriteStatement(oldStatement); + if (oldStatement != newStatement && builder is null) + { + builder = ImmutableArray.CreateBuilder(node.Statements.Length); + for (var j = 0; j < i; i++) + { + builder.Add(node.Statements[j]); + } + } + if (builder is not null) + { + builder.Add(newStatement); + } + + } + + if (builder is null) + { + return node; + } + + return new BoundBlockStatement(node.Syntax, builder.MoveToImmutable()); + } + + public virtual BoundStatement RewriteAbstractMethodDeclaration(BoundAbstractMethodDeclaration node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteExpression(BoundExpression node) + { + return node.Kind switch + { + BoundNodeKind.ArrayLiteralExpression => + RewriteArrayLiteralExpression((BoundArrayLiteralExpression)node), + BoundNodeKind.AssignmentExpression => + RewriteAssignmentExpression((BoundAssignmentExpression)node), + BoundNodeKind.BinaryOperationExpression => + RewriteBinaryOperationExpression((BoundBinaryOperationExpression)node), + BoundNodeKind.CellArrayElementAccessExpression => + RewriteCellArrayElementAccessExpression((BoundCellArrayElementAccessExpression)node), + BoundNodeKind.CellArrayLiteralExpression => + RewriteCellArrayLiteralExpression((BoundCellArrayLiteralExpression)node), + BoundNodeKind.ClassInvokationExpression => + RewriteClassInvokationExpression((BoundClassInvokationExpression)node), + BoundNodeKind.CommandExpression => + RewriteCommandExpression((BoundCommandExpression)node), + BoundNodeKind.CompoundNameExpression => + RewriteCompoundNameExpression((BoundCompoundNameExpression)node), + BoundNodeKind.DoubleQuotedStringLiteralExpression => + RewriteDoubleQuotedStringLiteralExpression((BoundDoubleQuotedStringLiteralExpression)node), + BoundNodeKind.EmptyExpression => + RewriteEmptyExpression((BoundEmptyExpression)node), + BoundNodeKind.FunctionCallExpression => + RewriteFunctionCallExpression((BoundFunctionCallExpression)node), + BoundNodeKind.IdentifierNameExpression => + RewriteIdentifierNameExpression((BoundIdentifierNameExpression)node), + BoundNodeKind.IndirectMemberAccessExpression => + RewriteIndirectMemberAccessExpression((BoundIndirectMemberAccessExpression)node), + BoundNodeKind.LambdaExpression => + RewriteLambdaExpression((BoundLambdaExpression)node), + BoundNodeKind.MemberAccessExpression => + RewriteMemberAccessExpression((BoundMemberAccessExpression)node), + BoundNodeKind.NamedFunctionHandleExpression => + RewriteNamedFunctionHandleExpression((BoundNamedFunctionHandleExpression)node), + BoundNodeKind.NumberLiteralExpression => + RewriteNumberLiteralExpression((BoundNumberLiteralExpression)node), + BoundNodeKind.ParenthesizedExpression => + RewriteParenthesizedExpression((BoundParenthesizedExpression)node), + BoundNodeKind.StringLiteralExpression => + RewriteStringLiteralExpression((BoundStringLiteralExpression)node), + BoundNodeKind.UnaryPrefixOperationExpression => + RewriteUnaryPrefixOperationExpression((BoundUnaryPrefixOperationExpression)node), + BoundNodeKind.UnaryPostfixOperationExpression => + RewriteUnaryPostfixOperationExpression((BoundUnaryPostfixOperationExpression)node), + BoundNodeKind.UnquotedStringLiteralExpression => + RewriteUnquotedStringLiteralExpression((BoundUnquotedStringLiteralExpression)node), + _ => + throw new Exception($"Invalid expression kind {node.Kind}."), + }; + } + + public virtual BoundExpression RewriteUnquotedStringLiteralExpression(BoundUnquotedStringLiteralExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteUnaryPostfixOperationExpression(BoundUnaryPostfixOperationExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteUnaryPrefixOperationExpression(BoundUnaryPrefixOperationExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteStringLiteralExpression(BoundStringLiteralExpression node) + { + return node; + } + + public virtual BoundExpression RewriteParenthesizedExpression(BoundParenthesizedExpression node) + { + var expression = RewriteExpression(node.Expression); + if (expression == node.Expression) + { + return node; + } + + return new BoundParenthesizedExpression(node.Syntax, expression); + } + + public virtual BoundExpression RewriteNumberLiteralExpression(BoundNumberLiteralExpression node) + { + return node; + } + + public virtual BoundExpression RewriteNamedFunctionHandleExpression(BoundNamedFunctionHandleExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteMemberAccessExpression(BoundMemberAccessExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteLambdaExpression(BoundLambdaExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteIndirectMemberAccessExpression(BoundIndirectMemberAccessExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteIdentifierNameExpression(BoundIdentifierNameExpression node) + { + return node; + } + + public virtual BoundExpression RewriteFunctionCallExpression(BoundFunctionCallExpression node) + { + + ImmutableArray.Builder? builder = null; + for (var i = 0; i < node.Arguments.Length; i++) + { + var oldArgument = node.Arguments[i]; + var newArgument = RewriteExpression(oldArgument); + if (oldArgument != newArgument && builder is null) + { + builder = ImmutableArray.CreateBuilder(node.Arguments.Length); + for (var j = 0; j < i; i++) + { + builder.Add(node.Arguments[j]); + } + } + if (builder is not null) + { + builder.Add(newArgument); + } + + } + + if (builder is null) + { + return node; + } + + return new BoundFunctionCallExpression(node.Syntax, node.Name, builder.MoveToImmutable()); + } + + public virtual BoundExpression RewriteEmptyExpression(BoundEmptyExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteDoubleQuotedStringLiteralExpression(BoundDoubleQuotedStringLiteralExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteCommandExpression(BoundCommandExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteCompoundNameExpression(BoundCompoundNameExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteClassInvokationExpression(BoundClassInvokationExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteCellArrayLiteralExpression(BoundCellArrayLiteralExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteCellArrayElementAccessExpression(BoundCellArrayElementAccessExpression node) + { + throw new NotImplementedException(); + } + + public virtual BoundExpression RewriteBinaryOperationExpression(BoundBinaryOperationExpression node) + { + var left = RewriteExpression(node.Left); + var right = RewriteExpression(node.Right); + if (left == node.Left && right == node.Right) + { + return node; + } + + return new BoundBinaryOperationExpression(node.Syntax, left, node.Op, right); + } + + public virtual BoundExpression RewriteAssignmentExpression(BoundAssignmentExpression node) + { + var left = RewriteExpression(node.Left); + var right = RewriteExpression(node.Right); + if (left == node.Left && right == node.Right) + { + return node; + } + + return new BoundAssignmentExpression(node.Syntax, left, right); + } + + public virtual BoundExpression RewriteArrayLiteralExpression(BoundArrayLiteralExpression node) + { + throw new NotImplementedException(); + } + } +} diff --git a/Parser/Internal/SyntaxFactory.Generated.cs b/Parser/Internal/SyntaxFactory.Generated.cs index edfbbb1..48981b9 100644 --- a/Parser/Internal/SyntaxFactory.Generated.cs +++ b/Parser/Internal/SyntaxFactory.Generated.cs @@ -13,7 +13,7 @@ namespace Parser.Internal return new BlockStatementSyntaxNode(statements); } - public FunctionDeclarationSyntaxNode FunctionDeclarationSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, BlockStatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword) + public FunctionDeclarationSyntaxNode FunctionDeclarationSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, StatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword) { return new FunctionDeclarationSyntaxNode(functionKeyword, outputDescription, name, inputDescription, commas, body, endKeyword); } @@ -33,32 +33,32 @@ namespace Parser.Internal return new SwitchStatementSyntaxNode(switchKeyword, switchExpression, optionalCommas, cases, endKeyword); } - public SwitchCaseSyntaxNode SwitchCaseSyntax(SyntaxToken caseKeyword, ExpressionSyntaxNode caseIdentifier, SyntaxList optionalCommas, BlockStatementSyntaxNode body) + public SwitchCaseSyntaxNode SwitchCaseSyntax(SyntaxToken caseKeyword, ExpressionSyntaxNode caseIdentifier, SyntaxList optionalCommas, StatementSyntaxNode body) { return new SwitchCaseSyntaxNode(caseKeyword, caseIdentifier, optionalCommas, body); } - public WhileStatementSyntaxNode WhileStatementSyntax(SyntaxToken whileKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, BlockStatementSyntaxNode body, SyntaxToken endKeyword) + public WhileStatementSyntaxNode WhileStatementSyntax(SyntaxToken whileKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxToken endKeyword) { return new WhileStatementSyntaxNode(whileKeyword, condition, optionalCommas, body, endKeyword); } - public ElseifClause ElseifClause(SyntaxToken elseifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, BlockStatementSyntaxNode body) + public ElseifClause ElseifClause(SyntaxToken elseifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body) { return new ElseifClause(elseifKeyword, condition, optionalCommas, body); } - public ElseClause ElseClause(SyntaxToken elseKeyword, BlockStatementSyntaxNode body) + public ElseClause ElseClause(SyntaxToken elseKeyword, StatementSyntaxNode body) { return new ElseClause(elseKeyword, body); } - public IfStatementSyntaxNode IfStatementSyntax(SyntaxToken ifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, BlockStatementSyntaxNode body, SyntaxList elseifClauses, ElseClause? elseClause, SyntaxToken endKeyword) + public IfStatementSyntaxNode IfStatementSyntax(SyntaxToken ifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxList elseifClauses, ElseClause? elseClause, SyntaxToken endKeyword) { return new IfStatementSyntaxNode(ifKeyword, condition, optionalCommas, body, elseifClauses, elseClause, endKeyword); } - public ForStatementSyntaxNode ForStatementSyntax(SyntaxToken forKeyword, AssignmentExpressionSyntaxNode assignment, SyntaxList optionalCommas, BlockStatementSyntaxNode body, SyntaxToken endKeyword) + public ForStatementSyntaxNode ForStatementSyntax(SyntaxToken forKeyword, AssignmentExpressionSyntaxNode assignment, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxToken endKeyword) { return new ForStatementSyntaxNode(forKeyword, assignment, optionalCommas, body, endKeyword); } @@ -73,7 +73,7 @@ namespace Parser.Internal return new CatchClauseSyntaxNode(catchKeyword, catchBody); } - public TryCatchStatementSyntaxNode TryCatchStatementSyntax(SyntaxToken tryKeyword, BlockStatementSyntaxNode tryBody, CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword) + public TryCatchStatementSyntaxNode TryCatchStatementSyntax(SyntaxToken tryKeyword, StatementSyntaxNode tryBody, CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword) { return new TryCatchStatementSyntaxNode(tryKeyword, tryBody, catchClause, endKeyword); } @@ -208,7 +208,7 @@ namespace Parser.Internal return new AttributeListSyntaxNode(openingBracket, nodes, closingBracket); } - public ConcreteMethodDeclarationSyntaxNode ConcreteMethodDeclarationSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, BlockStatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword) + public ConcreteMethodDeclarationSyntaxNode ConcreteMethodDeclarationSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, StatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword) { return new ConcreteMethodDeclarationSyntaxNode(functionKeyword, outputDescription, name, inputDescription, commas, body, endKeyword); } diff --git a/Parser/Internal/SyntaxNode.Generated.cs b/Parser/Internal/SyntaxNode.Generated.cs index 9ca04cc..014c271 100644 --- a/Parser/Internal/SyntaxNode.Generated.cs +++ b/Parser/Internal/SyntaxNode.Generated.cs @@ -89,9 +89,9 @@ namespace Parser.Internal internal readonly SyntaxToken _name; internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription; internal readonly SyntaxList _commas; - internal readonly BlockStatementSyntaxNode _body; + internal readonly StatementSyntaxNode _body; internal readonly EndKeywordSyntaxNode? _endKeyword; - internal FunctionDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, BlockStatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.FunctionDeclaration) + internal FunctionDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, StatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.FunctionDeclaration) { Slots = 7; this.AdjustWidth(functionKeyword); @@ -110,7 +110,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal FunctionDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, BlockStatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.FunctionDeclaration, diagnostics) + internal FunctionDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, StatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.FunctionDeclaration, diagnostics) { Slots = 7; this.AdjustWidth(functionKeyword); @@ -304,8 +304,8 @@ namespace Parser.Internal internal readonly SyntaxToken _caseKeyword; internal readonly ExpressionSyntaxNode _caseIdentifier; internal readonly SyntaxList _optionalCommas; - internal readonly BlockStatementSyntaxNode _body; - internal SwitchCaseSyntaxNode(SyntaxToken caseKeyword, ExpressionSyntaxNode caseIdentifier, SyntaxList optionalCommas, BlockStatementSyntaxNode body): base(TokenKind.SwitchCase) + internal readonly StatementSyntaxNode _body; + internal SwitchCaseSyntaxNode(SyntaxToken caseKeyword, ExpressionSyntaxNode caseIdentifier, SyntaxList optionalCommas, StatementSyntaxNode body): base(TokenKind.SwitchCase) { Slots = 4; this.AdjustWidth(caseKeyword); @@ -318,7 +318,7 @@ namespace Parser.Internal _body = body; } - internal SwitchCaseSyntaxNode(SyntaxToken caseKeyword, ExpressionSyntaxNode caseIdentifier, SyntaxList optionalCommas, BlockStatementSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.SwitchCase, diagnostics) + internal SwitchCaseSyntaxNode(SyntaxToken caseKeyword, ExpressionSyntaxNode caseIdentifier, SyntaxList optionalCommas, StatementSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.SwitchCase, diagnostics) { Slots = 4; this.AdjustWidth(caseKeyword); @@ -357,9 +357,9 @@ namespace Parser.Internal internal readonly SyntaxToken _whileKeyword; internal readonly ExpressionSyntaxNode _condition; internal readonly SyntaxList _optionalCommas; - internal readonly BlockStatementSyntaxNode _body; + internal readonly StatementSyntaxNode _body; internal readonly SyntaxToken _endKeyword; - internal WhileStatementSyntaxNode(SyntaxToken whileKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, BlockStatementSyntaxNode body, SyntaxToken endKeyword): base(TokenKind.WhileStatement) + internal WhileStatementSyntaxNode(SyntaxToken whileKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxToken endKeyword): base(TokenKind.WhileStatement) { Slots = 5; this.AdjustWidth(whileKeyword); @@ -374,7 +374,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal WhileStatementSyntaxNode(SyntaxToken whileKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, BlockStatementSyntaxNode body, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.WhileStatement, diagnostics) + internal WhileStatementSyntaxNode(SyntaxToken whileKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.WhileStatement, diagnostics) { Slots = 5; this.AdjustWidth(whileKeyword); @@ -415,8 +415,8 @@ namespace Parser.Internal internal readonly SyntaxToken _elseifKeyword; internal readonly ExpressionSyntaxNode _condition; internal readonly SyntaxList _optionalCommas; - internal readonly BlockStatementSyntaxNode _body; - internal ElseifClause(SyntaxToken elseifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, BlockStatementSyntaxNode body): base(TokenKind.ElseifClause) + internal readonly StatementSyntaxNode _body; + internal ElseifClause(SyntaxToken elseifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body): base(TokenKind.ElseifClause) { Slots = 4; this.AdjustWidth(elseifKeyword); @@ -429,7 +429,7 @@ namespace Parser.Internal _body = body; } - internal ElseifClause(SyntaxToken elseifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, BlockStatementSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.ElseifClause, diagnostics) + internal ElseifClause(SyntaxToken elseifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.ElseifClause, diagnostics) { Slots = 4; this.AdjustWidth(elseifKeyword); @@ -466,8 +466,8 @@ namespace Parser.Internal internal class ElseClause : SyntaxNode { internal readonly SyntaxToken _elseKeyword; - internal readonly BlockStatementSyntaxNode _body; - internal ElseClause(SyntaxToken elseKeyword, BlockStatementSyntaxNode body): base(TokenKind.ElseClause) + internal readonly StatementSyntaxNode _body; + internal ElseClause(SyntaxToken elseKeyword, StatementSyntaxNode body): base(TokenKind.ElseClause) { Slots = 2; this.AdjustWidth(elseKeyword); @@ -476,7 +476,7 @@ namespace Parser.Internal _body = body; } - internal ElseClause(SyntaxToken elseKeyword, BlockStatementSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.ElseClause, diagnostics) + internal ElseClause(SyntaxToken elseKeyword, StatementSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.ElseClause, diagnostics) { Slots = 2; this.AdjustWidth(elseKeyword); @@ -511,11 +511,11 @@ namespace Parser.Internal internal readonly SyntaxToken _ifKeyword; internal readonly ExpressionSyntaxNode _condition; internal readonly SyntaxList _optionalCommas; - internal readonly BlockStatementSyntaxNode _body; + internal readonly StatementSyntaxNode _body; internal readonly SyntaxList _elseifClauses; internal readonly ElseClause? _elseClause; internal readonly SyntaxToken _endKeyword; - internal IfStatementSyntaxNode(SyntaxToken ifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, BlockStatementSyntaxNode body, SyntaxList elseifClauses, ElseClause? elseClause, SyntaxToken endKeyword): base(TokenKind.IfStatement) + internal IfStatementSyntaxNode(SyntaxToken ifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxList elseifClauses, ElseClause? elseClause, SyntaxToken endKeyword): base(TokenKind.IfStatement) { Slots = 7; this.AdjustWidth(ifKeyword); @@ -534,7 +534,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal IfStatementSyntaxNode(SyntaxToken ifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, BlockStatementSyntaxNode body, SyntaxList elseifClauses, ElseClause? elseClause, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.IfStatement, diagnostics) + internal IfStatementSyntaxNode(SyntaxToken ifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxList elseifClauses, ElseClause? elseClause, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.IfStatement, diagnostics) { Slots = 7; this.AdjustWidth(ifKeyword); @@ -579,9 +579,9 @@ namespace Parser.Internal internal readonly SyntaxToken _forKeyword; internal readonly AssignmentExpressionSyntaxNode _assignment; internal readonly SyntaxList _optionalCommas; - internal readonly BlockStatementSyntaxNode _body; + internal readonly StatementSyntaxNode _body; internal readonly SyntaxToken _endKeyword; - internal ForStatementSyntaxNode(SyntaxToken forKeyword, AssignmentExpressionSyntaxNode assignment, SyntaxList optionalCommas, BlockStatementSyntaxNode body, SyntaxToken endKeyword): base(TokenKind.ForStatement) + internal ForStatementSyntaxNode(SyntaxToken forKeyword, AssignmentExpressionSyntaxNode assignment, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxToken endKeyword): base(TokenKind.ForStatement) { Slots = 5; this.AdjustWidth(forKeyword); @@ -596,7 +596,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal ForStatementSyntaxNode(SyntaxToken forKeyword, AssignmentExpressionSyntaxNode assignment, SyntaxList optionalCommas, BlockStatementSyntaxNode body, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ForStatement, diagnostics) + internal ForStatementSyntaxNode(SyntaxToken forKeyword, AssignmentExpressionSyntaxNode assignment, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ForStatement, diagnostics) { Slots = 5; this.AdjustWidth(forKeyword); @@ -726,10 +726,10 @@ namespace Parser.Internal internal class TryCatchStatementSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _tryKeyword; - internal readonly BlockStatementSyntaxNode _tryBody; + internal readonly StatementSyntaxNode _tryBody; internal readonly CatchClauseSyntaxNode? _catchClause; internal readonly SyntaxToken _endKeyword; - internal TryCatchStatementSyntaxNode(SyntaxToken tryKeyword, BlockStatementSyntaxNode tryBody, CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword): base(TokenKind.TryCatchStatement) + internal TryCatchStatementSyntaxNode(SyntaxToken tryKeyword, StatementSyntaxNode tryBody, CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword): base(TokenKind.TryCatchStatement) { Slots = 4; this.AdjustWidth(tryKeyword); @@ -742,7 +742,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal TryCatchStatementSyntaxNode(SyntaxToken tryKeyword, BlockStatementSyntaxNode tryBody, CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.TryCatchStatement, diagnostics) + internal TryCatchStatementSyntaxNode(SyntaxToken tryKeyword, StatementSyntaxNode tryBody, CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.TryCatchStatement, diagnostics) { Slots = 4; this.AdjustWidth(tryKeyword); @@ -1916,9 +1916,9 @@ namespace Parser.Internal internal readonly CompoundNameExpressionSyntaxNode _name; internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription; internal readonly SyntaxList _commas; - internal readonly BlockStatementSyntaxNode _body; + internal readonly StatementSyntaxNode _body; internal readonly EndKeywordSyntaxNode? _endKeyword; - internal ConcreteMethodDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, BlockStatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.ConcreteMethodDeclaration) + internal ConcreteMethodDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, StatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.ConcreteMethodDeclaration) { Slots = 7; this.AdjustWidth(functionKeyword); @@ -1937,7 +1937,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal ConcreteMethodDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, BlockStatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ConcreteMethodDeclaration, diagnostics) + internal ConcreteMethodDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, StatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ConcreteMethodDeclaration, diagnostics) { Slots = 7; this.AdjustWidth(functionKeyword); diff --git a/Parser/Parser.csproj b/Parser/Parser.csproj index be517b0..acfb9dc 100644 --- a/Parser/Parser.csproj +++ b/Parser/Parser.csproj @@ -3,6 +3,7 @@ netcoreapp3.0 8.0 enable + preview diff --git a/Parser/SyntaxDefinition.xml b/Parser/SyntaxDefinition.xml index 1ca6f1f..d3baf5d 100644 --- a/Parser/SyntaxDefinition.xml +++ b/Parser/SyntaxDefinition.xml @@ -13,7 +13,7 @@ - + @@ -36,30 +36,30 @@ - + - + - + - + - + @@ -68,7 +68,7 @@ - + @@ -82,7 +82,7 @@ - + @@ -199,7 +199,7 @@ - + diff --git a/Parser/SyntaxNode.Generated.cs b/Parser/SyntaxNode.Generated.cs index b99f89d..9b60cbd 100644 --- a/Parser/SyntaxNode.Generated.cs +++ b/Parser/SyntaxNode.Generated.cs @@ -127,12 +127,12 @@ namespace Parser } } - public BlockStatementSyntaxNode Body + public StatementSyntaxNode Body { get { var red = this.GetRed(ref this._body!, 5); - return red is null ? throw new System.Exception("body cannot be null.") : (BlockStatementSyntaxNode)red; + return red is null ? throw new System.Exception("body cannot be null.") : (StatementSyntaxNode)red; } } @@ -352,12 +352,12 @@ namespace Parser } } - public BlockStatementSyntaxNode Body + public StatementSyntaxNode Body { get { var red = this.GetRed(ref this._body!, 3); - return red is null ? throw new System.Exception("body cannot be null.") : (BlockStatementSyntaxNode)red; + return red is null ? throw new System.Exception("body cannot be null.") : (StatementSyntaxNode)red; } } @@ -420,12 +420,12 @@ namespace Parser } } - public BlockStatementSyntaxNode Body + public StatementSyntaxNode Body { get { var red = this.GetRed(ref this._body!, 3); - return red is null ? throw new System.Exception("body cannot be null.") : (BlockStatementSyntaxNode)red; + return red is null ? throw new System.Exception("body cannot be null.") : (StatementSyntaxNode)red; } } @@ -480,12 +480,12 @@ namespace Parser } } - public BlockStatementSyntaxNode Body + public StatementSyntaxNode Body { get { var red = this.GetRed(ref this._body!, 3); - return red is null ? throw new System.Exception("body cannot be null.") : (BlockStatementSyntaxNode)red; + return red is null ? throw new System.Exception("body cannot be null.") : (StatementSyntaxNode)red; } } @@ -520,12 +520,12 @@ namespace Parser } } - public BlockStatementSyntaxNode Body + public StatementSyntaxNode Body { get { var red = this.GetRed(ref this._body!, 1); - return red is null ? throw new System.Exception("body cannot be null.") : (BlockStatementSyntaxNode)red; + return red is null ? throw new System.Exception("body cannot be null.") : (StatementSyntaxNode)red; } } @@ -590,12 +590,12 @@ namespace Parser } } - public BlockStatementSyntaxNode Body + public StatementSyntaxNode Body { get { var red = this.GetRed(ref this._body!, 3); - return red is null ? throw new System.Exception("body cannot be null.") : (BlockStatementSyntaxNode)red; + return red is null ? throw new System.Exception("body cannot be null.") : (StatementSyntaxNode)red; } } @@ -676,12 +676,12 @@ namespace Parser } } - public BlockStatementSyntaxNode Body + public StatementSyntaxNode Body { get { var red = this.GetRed(ref this._body!, 3); - return red is null ? throw new System.Exception("body cannot be null.") : (BlockStatementSyntaxNode)red; + return red is null ? throw new System.Exception("body cannot be null.") : (StatementSyntaxNode)red; } } @@ -815,12 +815,12 @@ namespace Parser } } - public BlockStatementSyntaxNode TryBody + public StatementSyntaxNode TryBody { get { var red = this.GetRed(ref this._tryBody!, 1); - return red is null ? throw new System.Exception("tryBody cannot be null.") : (BlockStatementSyntaxNode)red; + return red is null ? throw new System.Exception("tryBody cannot be null.") : (StatementSyntaxNode)red; } } @@ -1967,12 +1967,12 @@ namespace Parser } } - public BlockStatementSyntaxNode Body + public StatementSyntaxNode Body { get { var red = this.GetRed(ref this._body!, 5); - return red is null ? throw new System.Exception("body cannot be null.") : (BlockStatementSyntaxNode)red; + return red is null ? throw new System.Exception("body cannot be null.") : (StatementSyntaxNode)red; } }