From 188dca85d84f8c804a8a661a28c66d93e696ba8e Mon Sep 17 00:00:00 2001 From: Alexander Luzgarev Date: Tue, 14 Jul 2020 22:45:34 +0200 Subject: [PATCH] Introduce binding --- ConsoleDemo/DumbWalker.cs | 4 +- ConsoleDemo/PrettyPrinter.cs | 18 +- ConsoleDemo/UsageGathering.cs | 4 +- MApplication/ColoringVisitor.cs | 18 +- Parser/Binding/Binder.cs | 353 +++++++++++++ Parser/Binding/BoundProgram.cs | 20 + Parser/Binding/BoundRoot.cs | 581 +++++++++++++++++++++ Parser/Compilation.cs | 17 +- Parser/Evaluator.cs | 294 +++++------ Parser/Internal/MParserGreen.cs | 30 +- Parser/Internal/SyntaxFactory.Generated.cs | 38 +- Parser/Internal/SyntaxNode.Generated.cs | 96 ++-- Parser/SyntaxDefinition.xml | 20 +- Parser/SyntaxNode.Generated.cs | 74 +-- Parser/SyntaxVisitor.Generated.cs | 18 +- Repl/MRepl.cs | 6 +- Semantics/GetClass.cs | 4 +- examples/helloworld/hello.m | 14 +- 18 files changed, 1290 insertions(+), 319 deletions(-) create mode 100644 Parser/Binding/Binder.cs create mode 100644 Parser/Binding/BoundProgram.cs create mode 100644 Parser/Binding/BoundRoot.cs diff --git a/ConsoleDemo/DumbWalker.cs b/ConsoleDemo/DumbWalker.cs index 7914769..fc3bd64 100644 --- a/ConsoleDemo/DumbWalker.cs +++ b/ConsoleDemo/DumbWalker.cs @@ -159,10 +159,10 @@ namespace ConsoleDemo _insideFunction = false; } - public override void VisitMethodDefinition(MethodDefinitionSyntaxNode node) + public override void VisitConcreteMethodDeclaration(ConcreteMethodDeclarationSyntaxNode node) { _insideMethod = true; - base.VisitMethodDefinition(node); + base.VisitConcreteMethodDeclaration(node); _insideMethod = false; } diff --git a/ConsoleDemo/PrettyPrinter.cs b/ConsoleDemo/PrettyPrinter.cs index c5221f7..3dab17f 100644 --- a/ConsoleDemo/PrettyPrinter.cs +++ b/ConsoleDemo/PrettyPrinter.cs @@ -186,7 +186,7 @@ namespace ProjectConsole OutputKeyword(node.EndKeyword); } - public override void VisitMethodDefinition(MethodDefinitionSyntaxNode node) + public override void VisitConcreteMethodDeclaration(ConcreteMethodDeclarationSyntaxNode node) { OutputKeyword(node.FunctionKeyword); Visit(node.OutputDescription); @@ -306,12 +306,12 @@ namespace ProjectConsole OutputControlKeyword(node.EndKeyword); } - public override void VisitUnquotedStringLiteral(UnquotedStringLiteralSyntaxNode node) + public override void VisitUnquotedStringLiteralExpression(UnquotedStringLiteralExpressionSyntaxNode node) { OutputUnquotedStringLiteral(node.StringToken); } - public override void VisitStringLiteral(StringLiteralSyntaxNode node) + public override void VisitStringLiteralExpression(StringLiteralExpressionSyntaxNode node) { OutputStringLiteral(node.StringToken); } @@ -359,7 +359,7 @@ namespace ProjectConsole Visit(node.Arguments); } - public override void VisitNumberLiteral(NumberLiteralSyntaxNode node) + public override void VisitNumberLiteralExpression(NumberLiteralExpressionSyntaxNode node) { OutputNumberLiteral(node.Number); } @@ -370,13 +370,13 @@ namespace ProjectConsole Visit(node.Operand); } - public override void VisitUnaryPostixOperationExpression(UnaryPostixOperationExpressionSyntaxNode node) + public override void VisitUnaryPostfixOperationExpression(UnaryPostfixOperationExpressionSyntaxNode node) { Visit(node.Operand); OutputOperator(node.Operation); } - public override void VisitBaseClassInvokation(BaseClassInvokationSyntaxNode node) + public override void VisitClassInvokationExpression(ClassInvokationExpressionSyntaxNode node) { Visit(node.MethodName); OutputOperator(node.AtSign); @@ -415,7 +415,7 @@ namespace ProjectConsole Visit(node.Nodes); } - public override void VisitDoubleQuotedStringLiteral(DoubleQuotedStringLiteralSyntaxNode node) + public override void VisitDoubleQuotedStringLiteralExpression(DoubleQuotedStringLiteralExpressionSyntaxNode node) { OutputStringLiteral(node.StringToken); } @@ -472,7 +472,7 @@ namespace ProjectConsole OutputOperator(node.AssignmentSign); } - public override void VisitIndirectMemberAccess(IndirectMemberAccessSyntaxNode node) + public override void VisitIndirectMemberAccessExpression(IndirectMemberAccessExpressionSyntaxNode node) { OutputBracket(node.OpeningBracket); Visit(node.Expression); @@ -492,7 +492,7 @@ namespace ProjectConsole Visit(node.FunctionName); } - public override void VisitMemberAccess(MemberAccessSyntaxNode node) + public override void VisitMemberAccessExpression(MemberAccessExpressionSyntaxNode node) { Visit(node.LeftOperand); OutputOperator(node.Dot); diff --git a/ConsoleDemo/UsageGathering.cs b/ConsoleDemo/UsageGathering.cs index 6665443..9b227a6 100644 --- a/ConsoleDemo/UsageGathering.cs +++ b/ConsoleDemo/UsageGathering.cs @@ -120,7 +120,7 @@ namespace ConsoleDemo _insideFunction = false; } - public override void VisitMethodDefinition(MethodDefinitionSyntaxNode node) + public override void VisitConcreteMethodDeclaration(ConcreteMethodDeclarationSyntaxNode node) { _insideMethod = true; _variableAssignments = new VariableAssignments(); @@ -146,7 +146,7 @@ namespace ConsoleDemo Console.WriteLine($"Parameter token: {parameter.AsToken()}"); } } - base.VisitMethodDefinition(node); + base.VisitConcreteMethodDeclaration(node); _variableAssignments = null; _insideMethod = false; } diff --git a/MApplication/ColoringVisitor.cs b/MApplication/ColoringVisitor.cs index 3504b19..ba9e4c7 100644 --- a/MApplication/ColoringVisitor.cs +++ b/MApplication/ColoringVisitor.cs @@ -138,7 +138,7 @@ namespace MApplication AddToken(node.EndKeyword, _scheme.Keyword); } - public override void VisitMethodDefinition(MethodDefinitionSyntaxNode node) + public override void VisitConcreteMethodDeclaration(ConcreteMethodDeclarationSyntaxNode node) { AddToken(node.FunctionKeyword, _scheme.Keyword); Visit(node.OutputDescription); @@ -253,12 +253,12 @@ namespace MApplication AddToken(node.EndKeyword, _scheme.ControlKeyword); } - public override void VisitUnquotedStringLiteral(UnquotedStringLiteralSyntaxNode node) + public override void VisitUnquotedStringLiteralExpression(UnquotedStringLiteralExpressionSyntaxNode node) { AddToken(node.StringToken, _scheme.UnquotedStringLiteral); } - public override void VisitStringLiteral(StringLiteralSyntaxNode node) + public override void VisitStringLiteralExpression(StringLiteralExpressionSyntaxNode node) { AddToken(node.StringToken, _scheme.StringLiteral); } @@ -306,7 +306,7 @@ namespace MApplication Visit(node.Arguments); } - public override void VisitNumberLiteral(NumberLiteralSyntaxNode node) + public override void VisitNumberLiteralExpression(NumberLiteralExpressionSyntaxNode node) { AddToken(node.Number, _scheme.NumberLiteral); } @@ -317,13 +317,13 @@ namespace MApplication Visit(node.Operand); } - public override void VisitUnaryPostixOperationExpression(UnaryPostixOperationExpressionSyntaxNode node) + public override void VisitUnaryPostfixOperationExpression(UnaryPostfixOperationExpressionSyntaxNode node) { Visit(node.Operand); AddToken(node.Operation, _scheme.Operator); } - public override void VisitBaseClassInvokation(BaseClassInvokationSyntaxNode node) + public override void VisitClassInvokationExpression(ClassInvokationExpressionSyntaxNode node) { Visit(node.MethodName); AddToken(node.AtSign, _scheme.Operator); @@ -362,7 +362,7 @@ namespace MApplication Visit(node.Nodes); } - public override void VisitDoubleQuotedStringLiteral(DoubleQuotedStringLiteralSyntaxNode node) + public override void VisitDoubleQuotedStringLiteralExpression(DoubleQuotedStringLiteralExpressionSyntaxNode node) { AddToken(node.StringToken, _scheme.StringLiteral); } @@ -419,7 +419,7 @@ namespace MApplication AddToken(node.AssignmentSign, _scheme.Operator); } - public override void VisitIndirectMemberAccess(IndirectMemberAccessSyntaxNode node) + public override void VisitIndirectMemberAccessExpression(IndirectMemberAccessExpressionSyntaxNode node) { AddToken(node.OpeningBracket, _scheme.Bracket); Visit(node.Expression); @@ -439,7 +439,7 @@ namespace MApplication Visit(node.FunctionName); } - public override void VisitMemberAccess(MemberAccessSyntaxNode node) + public override void VisitMemberAccessExpression(MemberAccessExpressionSyntaxNode node) { Visit(node.LeftOperand); AddToken(node.Dot, _scheme.Operator); diff --git a/Parser/Binding/Binder.cs b/Parser/Binding/Binder.cs new file mode 100644 index 0000000..23fb3fd --- /dev/null +++ b/Parser/Binding/Binder.cs @@ -0,0 +1,353 @@ +using Parser.Internal; +using System; +using System.Collections.Immutable; +using System.Linq; + +namespace Parser.Binding +{ + public class Binder + { + private readonly DiagnosticsBag _diagnostics = new DiagnosticsBag(); + + private BoundRoot BindRoot(RootSyntaxNode node) + { + var boundFile = BindFile(node.File); + return new BoundRoot(node, boundFile); + } + + private BoundFile BindFile(FileSyntaxNode node) + { + var statements = BindStatementList(node.StatementList); + return new BoundFile(node, statements); + } + + private BoundStatement BindStatement(StatementSyntaxNode node) + { + return node.Kind switch + { + TokenKind.AbstractMethodDeclaration => + BindAbstractMethodDeclaration((AbstractMethodDeclarationSyntaxNode)node), + TokenKind.ClassDeclaration => + BindClassDeclaration((ClassDeclarationSyntaxNode)node), + TokenKind.ConcreteMethodDeclaration => + BindConcreteMethodDeclaration((ConcreteMethodDeclarationSyntaxNode)node), + TokenKind.EmptyStatement => + BindEmptyStatement((EmptyStatementSyntaxNode)node), + TokenKind.ExpressionStatement => + BindExpressionStatement((ExpressionStatementSyntaxNode)node), + TokenKind.ForStatement => + BindForStatement((ForStatementSyntaxNode)node), + TokenKind.FunctionDeclaration => + BindFunctionDeclaration((FunctionDeclarationSyntaxNode)node), + TokenKind.IfStatement => + BindIfStatement((IfStatementSyntaxNode)node), + TokenKind.SwitchStatement => + BindSwitchStatement((SwitchStatementSyntaxNode)node), + TokenKind.TryCatchStatement => + BindTryCatchStatement((TryCatchStatementSyntaxNode)node), + TokenKind.WhileStatement => + BindWhileStatement((WhileStatementSyntaxNode)node), + _ => + throw new Exception($"Invalid statement node kind '{node.Kind}'."), + }; + } + + private BoundWhileStatement BindWhileStatement(WhileStatementSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundTryCatchStatement BindTryCatchStatement(TryCatchStatementSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundSwitchStatement BindSwitchStatement(SwitchStatementSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundIfStatement BindIfStatement(IfStatementSyntaxNode node) + { + var condition = BindExpression(node.Condition); + var body = BindStatementList(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 clause = BindElseIfClause(elseIfClause); + builder.Add(clause); + } + var maybeElseClause = node.ElseClause switch + { + { } elseClause => BindElseClause(elseClause), + _ => null, + }; + + return new BoundIfStatement(node, condition, body, elseIfClauses, maybeElseClause); + } + + private BoundElseClause BindElseClause(ElseClause node) + { + var body = BindStatementList(node.Body); + return new BoundElseClause(node, body); + } + + private ImmutableArray BindStatementList(SyntaxNodeOrTokenList list) + { + var builder = ImmutableArray.CreateBuilder(); + var statements = list.Where(s => s.IsNode).Select(s => (StatementSyntaxNode)s.AsNode()!); + foreach (var statement in statements) + { + var boundStatement = BindStatement(statement); + builder.Add(boundStatement); + } + + return builder.ToImmutable(); + } + + private ImmutableArray BindExpressionList(SyntaxNodeOrTokenList list) + { + var builder = ImmutableArray.CreateBuilder(); + var expressions = list.Where(s => s.IsNode).Select(s => (ExpressionSyntaxNode)s.AsNode()!); + foreach (var expression in expressions) + { + var boundExpression = BindExpression(expression); + builder.Add(boundExpression); + } + + return builder.ToImmutable(); + } + + private BoundElseIfClause BindElseIfClause(ElseifClause node) + { + var condition = BindExpression(node.Condition); + var body = BindStatementList(node.Body); + return new BoundElseIfClause(node, condition, body); + } + + private BoundFunctionDeclaration BindFunctionDeclaration(FunctionDeclarationSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundForStatement BindForStatement(ForStatementSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundExpressionStatement BindExpressionStatement(ExpressionStatementSyntaxNode node) + { + var expression = BindExpression(node.Expression); + return new BoundExpressionStatement(node, expression); + } + + private BoundExpression BindExpression(ExpressionSyntaxNode node) + { + return node.Kind switch + { + TokenKind.ArrayLiteralExpression => + BindArrayLiteralExpression((ArrayLiteralExpressionSyntaxNode)node), + TokenKind.AssignmentExpression => + BindAssignmentExpression((AssignmentExpressionSyntaxNode)node), + TokenKind.BinaryOperationExpression => + BindBinaryOperationExpression((BinaryOperationExpressionSyntaxNode)node), + TokenKind.CellArrayElementAccessExpression => + BindCellArrayElementAccessExpression((CellArrayElementAccessExpressionSyntaxNode)node), + TokenKind.CellArrayLiteralExpression => + BindCellArrayLiteralExpression((CellArrayLiteralExpressionSyntaxNode)node), + TokenKind.ClassInvokationExpression => + BindClassInvokationExpression((ClassInvokationExpressionSyntaxNode)node), + TokenKind.CommandExpression => + BindCommandExpression((CommandExpressionSyntaxNode)node), + TokenKind.CompoundNameExpression => + BindCompoundNameExpression((CompoundNameExpressionSyntaxNode)node), + TokenKind.DoubleQuotedStringLiteralExpression => + BindDoubleQuotedStringLiteralExpression((DoubleQuotedStringLiteralExpressionSyntaxNode)node), + TokenKind.EmptyExpression => + BindEmptyExpression((EmptyExpressionSyntaxNode)node), + TokenKind.FunctionCallExpression => + BindFunctionCallExpression((FunctionCallExpressionSyntaxNode)node), + TokenKind.IdentifierNameExpression => + BindIdentifierNameExpression((IdentifierNameExpressionSyntaxNode)node), + TokenKind.IndirectMemberAccessExpression => + BindIndirectMemberAccessExpression((IndirectMemberAccessExpressionSyntaxNode)node), + TokenKind.LambdaExpression => + BindLambdaExpression((LambdaExpressionSyntaxNode)node), + TokenKind.MemberAccessExpression => + BindMemberAccessExpression((MemberAccessExpressionSyntaxNode)node), + TokenKind.NamedFunctionHandleExpression => + BindNamedFunctionHandleExpression((NamedFunctionHandleExpressionSyntaxNode)node), + TokenKind.NumberLiteralExpression => + BindNumberLiteralExpression((NumberLiteralExpressionSyntaxNode)node), + TokenKind.ParenthesizedExpression => + BindParenthesizedExpression((ParenthesizedExpressionSyntaxNode)node), + TokenKind.StringLiteralExpression => + BindStringLiteralExpression((StringLiteralExpressionSyntaxNode)node), + TokenKind.UnaryPrefixOperationExpression => + BindUnaryPrefixOperationExpression((UnaryPrefixOperationExpressionSyntaxNode)node), + TokenKind.UnaryPostfixOperationExpression => + BindUnaryPostfixOperationExpression((UnaryPostfixOperationExpressionSyntaxNode)node), + TokenKind.UnquotedStringLiteralExpression => + BindUnquotedStringLiteralExpression((UnquotedStringLiteralExpressionSyntaxNode)node), + _ => + throw new Exception($"Invalid statement node kind '{node.Kind}'."), + }; + } + + private BoundArrayLiteralExpression BindArrayLiteralExpression(ArrayLiteralExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundAssignmentExpression BindAssignmentExpression(AssignmentExpressionSyntaxNode node) + { + var left = BindExpression(node.Lhs); + var right = BindExpression(node.Rhs); + return new BoundAssignmentExpression(node, left, right); + } + + private BoundBinaryOperationExpression BindBinaryOperationExpression(BinaryOperationExpressionSyntaxNode node) + { + var left = BindExpression(node.Lhs); + var right = BindExpression(node.Rhs); + var op = BindBinaryOperator(node.Operation); + return new BoundBinaryOperationExpression(node, left, op, right); + } + + private BoundBinaryOperator BindBinaryOperator(SyntaxToken token) + { + return BoundBinaryOperator.GetOperator(token.Kind) + ?? throw new Exception($"Unexpected binary operator kind {token.Kind}."); + } + + private BoundCellArrayElementAccessExpression BindCellArrayElementAccessExpression(CellArrayElementAccessExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundCellArrayLiteralExpression BindCellArrayLiteralExpression(CellArrayLiteralExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundClassInvokationExpression BindClassInvokationExpression(ClassInvokationExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundCommandExpression BindCommandExpression(CommandExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundCompoundNameExpression BindCompoundNameExpression(CompoundNameExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundDoubleQuotedStringLiteralExpression BindDoubleQuotedStringLiteralExpression(DoubleQuotedStringLiteralExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundEmptyExpression BindEmptyExpression(EmptyExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundFunctionCallExpression BindFunctionCallExpression(FunctionCallExpressionSyntaxNode node) + { + var name = BindExpression(node.FunctionName); + var arguments = BindExpressionList(node.Nodes); + return new BoundFunctionCallExpression(node, name, arguments); + } + + private BoundIdentifierNameExpression BindIdentifierNameExpression(IdentifierNameExpressionSyntaxNode node) + { + return new BoundIdentifierNameExpression(node, node.Name.Text); + } + + private BoundIndirectMemberAccessExpression BindIndirectMemberAccessExpression(IndirectMemberAccessExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundLambdaExpression BindLambdaExpression(LambdaExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundMemberAccessExpression BindMemberAccessExpression(MemberAccessExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundNamedFunctionHandleExpression BindNamedFunctionHandleExpression(NamedFunctionHandleExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundNumberLiteralExpression BindNumberLiteralExpression(NumberLiteralExpressionSyntaxNode node) + { + var value = (double)node.Number.Value!; + return new BoundNumberLiteralExpression(node, value); + } + + private BoundParenthesizedExpression BindParenthesizedExpression(ParenthesizedExpressionSyntaxNode node) + { + var expression = BindExpression(node.Expression); + return new BoundParenthesizedExpression(node, expression); + } + + private BoundStringLiteralExpression BindStringLiteralExpression(StringLiteralExpressionSyntaxNode node) + { + var value = (string)node.StringToken.Value!; + return new BoundStringLiteralExpression(node, value); + } + + private BoundUnaryPrefixOperationExpression BindUnaryPrefixOperationExpression(UnaryPrefixOperationExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundUnaryPostfixOperationExpression BindUnaryPostfixOperationExpression(UnaryPostfixOperationExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundUnquotedStringLiteralExpression BindUnquotedStringLiteralExpression(UnquotedStringLiteralExpressionSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundEmptyStatement BindEmptyStatement(EmptyStatementSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundConcreteMethodDeclaration BindConcreteMethodDeclaration(ConcreteMethodDeclarationSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundClassDeclaration BindClassDeclaration(ClassDeclarationSyntaxNode node) + { + throw new NotImplementedException(); + } + + private BoundAbstractMethodDeclaration BindAbstractMethodDeclaration(AbstractMethodDeclarationSyntaxNode node) + { + throw new NotImplementedException(); + } + + public static BoundProgram BindProgram(SyntaxTree syntaxTree) + { + var binder = new Binder(); + var boundRoot = binder.BindRoot(syntaxTree.NullRoot); + return new BoundProgram(boundRoot, binder._diagnostics.ToImmutableArray()); + } + } +} diff --git a/Parser/Binding/BoundProgram.cs b/Parser/Binding/BoundProgram.cs new file mode 100644 index 0000000..b6cfc94 --- /dev/null +++ b/Parser/Binding/BoundProgram.cs @@ -0,0 +1,20 @@ +using Parser.Internal; +using System.Collections.Immutable; + +namespace Parser.Binding +{ + public class BoundProgram + { + public BoundProgram(BoundRoot nullRoot, ImmutableArray diagnostics) + { + NullRoot = nullRoot; + Diagnostics = diagnostics; + } + + public ImmutableArray Diagnostics { get; } + + public BoundRoot NullRoot { get; } + + public BoundFile Root => NullRoot.File; + } +} diff --git a/Parser/Binding/BoundRoot.cs b/Parser/Binding/BoundRoot.cs new file mode 100644 index 0000000..b800a7e --- /dev/null +++ b/Parser/Binding/BoundRoot.cs @@ -0,0 +1,581 @@ +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Linq; + +namespace Parser.Binding +{ + public enum BoundNodeKind + { + Root, + File, + + // Statements + + AbstractMethodDeclaration, + 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) + : base(syntax) + { + File = file; + } + + public BoundFile File { get; } + + public override BoundNodeKind Kind => BoundNodeKind.Root; + } + + public class BoundFile : BoundNode + { + public BoundFile(SyntaxNode syntax, ImmutableArray statements) + : base(syntax) + { + Statements = statements; + } + + public ImmutableArray Statements { get; } + + public override BoundNodeKind Kind => BoundNodeKind.File; + } + + public abstract class BoundStatement : BoundNode + { + public BoundStatement(SyntaxNode syntax) + : base(syntax) + { + } + } + + public abstract class BoundMethodDeclaration : BoundStatement + { + public BoundMethodDeclaration(SyntaxNode syntax) + : base(syntax) + { + } + } + + public class BoundAbstractMethodDeclaration : BoundMethodDeclaration + { + public BoundAbstractMethodDeclaration(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.AbstractMethodDeclaration; + } + + public class BoundClassDeclaration : BoundStatement + { + public BoundClassDeclaration(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.ClassDeclaration; + } + + public class BoundConcreteMethodDeclaration : BoundMethodDeclaration + { + public BoundConcreteMethodDeclaration(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.ConcreteMethodDeclaration; + } + + public class BoundEmptyStatement : BoundStatement + { + public BoundEmptyStatement(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.EmptyStatement; + } + + public class BoundExpressionStatement : BoundStatement + { + public BoundExpression Expression { get; } + + public override BoundNodeKind Kind => BoundNodeKind.ExpressionStatement; + + public BoundExpressionStatement(SyntaxNode syntax, BoundExpression expression) + : base(syntax) + { + Expression = expression; + } + } + + public class BoundForStatement : BoundStatement + { + public BoundForStatement(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.ForStatement; + } + + public class BoundFunctionDeclaration : BoundStatement + { + public BoundFunctionDeclaration(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.FunctionDeclaration; + } + + public class BoundIfStatement : BoundStatement + { + public BoundIfStatement(SyntaxNode syntax, BoundExpression condition, ImmutableArray body, IEnumerable elseIfClauses, BoundElseClause? elseClause) + : base(syntax) + { + Condition = condition; + Body = body; + ElseIfClauses = elseIfClauses; + ElseClause = elseClause; + } + + public BoundExpression Condition { get; } + public ImmutableArray Body { get; } + public IEnumerable ElseIfClauses { get; } + public BoundElseClause? ElseClause { get; } + + public override BoundNodeKind Kind => BoundNodeKind.IfStatement; + } + + public class BoundSwitchStatement : BoundStatement + { + public BoundSwitchStatement(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.SwitchStatement; + } + + public class BoundTryCatchStatement : BoundStatement + { + public BoundTryCatchStatement(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.TryCatchStatement; + } + + public class BoundWhileStatement : BoundStatement + { + public BoundWhileStatement(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.WhileStatement; + } + + public abstract class BoundExpression : BoundNode + { + public BoundExpression(SyntaxNode syntax) + : base(syntax) + { + } + } + + public class BoundArrayLiteralExpression : BoundExpression + { + public BoundArrayLiteralExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.ArrayLiteralExpression; + } + + public class BoundAssignmentExpression : BoundExpression + { + public BoundAssignmentExpression(SyntaxNode syntax, BoundExpression left, BoundExpression right) + : base(syntax) + { + Left = left; + Right = right; + } + + public BoundExpression Left { get; } + public BoundExpression Right { get; } + + public override BoundNodeKind Kind => BoundNodeKind.AssignmentExpression; + } + + public class BoundBinaryOperationExpression : BoundExpression + { + public BoundBinaryOperationExpression(SyntaxNode syntax, BoundExpression left, BoundBinaryOperator op, BoundExpression right) + : base(syntax) + { + Left = left; + Op = op; + Right = right; + } + + public BoundExpression Left { get; } + public BoundBinaryOperator Op { get; } + public BoundExpression Right { get; } + + public override BoundNodeKind Kind => BoundNodeKind.BinaryOperationExpression; + } + + public class BoundCellArrayElementAccessExpression : BoundExpression + { + public BoundCellArrayElementAccessExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.CellArrayElementAccessExpression; + } + + public class BoundCellArrayLiteralExpression : BoundExpression + { + public BoundCellArrayLiteralExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.CellArrayLiteralExpression; + } + + public class BoundClassInvokationExpression : BoundExpression + { + public BoundClassInvokationExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.ClassInvokationExpression; + } + + public class BoundCommandExpression : BoundExpression + { + public BoundCommandExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.CommandExpression; + } + + public class BoundCompoundNameExpression : BoundExpression + { + public BoundCompoundNameExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.CompoundNameExpression; + } + + public class BoundDoubleQuotedStringLiteralExpression : BoundExpression + { + public BoundDoubleQuotedStringLiteralExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.DoubleQuotedStringLiteralExpression; + } + + public class BoundEmptyExpression : BoundExpression + { + public BoundEmptyExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.EmptyExpression; + } + + public class BoundFunctionCallExpression : BoundExpression + { + public BoundFunctionCallExpression(SyntaxNode syntax, BoundExpression name, ImmutableArray arguments) + : base(syntax) + { + Name = name; + Arguments = arguments; + } + + public BoundExpression Name { get; } + public ImmutableArray Arguments { get; } + public override BoundNodeKind Kind => BoundNodeKind.FunctionCallExpression; + } + + public class BoundIdentifierNameExpression : BoundExpression + { + public BoundIdentifierNameExpression(SyntaxNode syntax, string name) + : base(syntax) + { + Name = name; + } + + public string Name { get; } + public override BoundNodeKind Kind => BoundNodeKind.IdentifierNameExpression; + } + + public class BoundIndirectMemberAccessExpression : BoundExpression + { + public BoundIndirectMemberAccessExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.IndirectMemberAccessExpression; + } + + public class BoundLambdaExpression : BoundExpression + { + public BoundLambdaExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.LambdaExpression; + } + + public class BoundMemberAccessExpression : BoundExpression + { + public BoundMemberAccessExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.MemberAccessExpression; + } + + public class BoundNamedFunctionHandleExpression : BoundExpression + { + public BoundNamedFunctionHandleExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.NamedFunctionHandleExpression; + } + + public class BoundNumberLiteralExpression : BoundExpression + { + public BoundNumberLiteralExpression(SyntaxNode syntax, double value) + : base(syntax) + { + Value = value; + } + + public double Value { get; } + public override BoundNodeKind Kind => BoundNodeKind.NumberLiteralExpression; + } + + public class BoundParenthesizedExpression : BoundExpression + { + public BoundParenthesizedExpression(SyntaxNode syntax, BoundExpression expression) + : base(syntax) + { + Expression = expression; + } + + public override BoundNodeKind Kind => BoundNodeKind.ParenthesizedExpression; + + public BoundExpression Expression { get; } + } + + public class BoundStringLiteralExpression : BoundExpression + { + public BoundStringLiteralExpression(SyntaxNode syntax, string value) + : base(syntax) + { + Value = value; + } + + public string Value { get; } + public override BoundNodeKind Kind => BoundNodeKind.StringLiteralExpression; + } + + public class BoundUnaryPrefixOperationExpression : BoundExpression + { + public BoundUnaryPrefixOperationExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.UnaryPrefixOperationExpression; + } + + public class BoundUnaryPostfixOperationExpression : BoundExpression + { + public BoundUnaryPostfixOperationExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.UnaryPostfixOperationExpression; + } + + public class BoundUnquotedStringLiteralExpression : BoundExpression + { + public BoundUnquotedStringLiteralExpression(SyntaxNode syntax) + : base(syntax) + { + } + + public override BoundNodeKind Kind => BoundNodeKind.UnquotedStringLiteralExpression; + } + + public class BoundElseIfClause : BoundNode + { + public BoundElseIfClause(SyntaxNode syntax, BoundExpression condition, ImmutableArray body) + : base(syntax) + { + Condition = condition; + Body = body; + } + + public BoundExpression Condition { get; } + public ImmutableArray Body { get; } + public override BoundNodeKind Kind => BoundNodeKind.ElseIfClause; + } + + public class BoundElseClause : BoundNode + { + public BoundElseClause(SyntaxNode syntax, ImmutableArray body) + : base(syntax) + { + Body = body; + } + + public ImmutableArray 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/Compilation.cs b/Parser/Compilation.cs index c4668c6..8744a58 100644 --- a/Parser/Compilation.cs +++ b/Parser/Compilation.cs @@ -1,4 +1,6 @@ -namespace Parser +using Parser.Binding; + +namespace Parser { public class Compilation { @@ -14,9 +16,20 @@ return new Compilation(syntaxTree); } + private BoundProgram GetBoundProgram() + { + return Binder.BindProgram(_syntaxTree); + } + public EvaluationResult Evaluate(CompilationContext context) { - var evaluator = new Evaluator(_syntaxTree, context); + var program = GetBoundProgram(); + if (program.Diagnostics.Length > 0) + { + return new EvaluationResult(null, program.Diagnostics); + } + + var evaluator = new Evaluator(program, context); return evaluator.Evaluate(); } } diff --git a/Parser/Evaluator.cs b/Parser/Evaluator.cs index 74a1d6b..2a233a7 100644 --- a/Parser/Evaluator.cs +++ b/Parser/Evaluator.cs @@ -1,4 +1,5 @@ -using Parser.Internal; +using Parser.Binding; +using Parser.Internal; using Parser.MFunctions; using Parser.Objects; using System; @@ -10,15 +11,15 @@ namespace Parser { internal class Evaluator { - private readonly SyntaxTree _syntaxTree; + private readonly BoundProgram _program; private readonly CompilationContext _context; private readonly DiagnosticsBag _diagnostics = new DiagnosticsBag(); private bool _insideFunction = false; private readonly Stack _scopeStack = new Stack(); - public Evaluator(SyntaxTree syntaxTree, CompilationContext context) + public Evaluator(BoundProgram program, CompilationContext context) { - _syntaxTree = syntaxTree; + _program = program; _context = context; var outerScope = new EvaluationScope(); _scopeStack.Push(outerScope); @@ -26,209 +27,204 @@ namespace Parser internal EvaluationResult Evaluate() { - var result = EvaluateFile(_syntaxTree.Root); + var result = EvaluateFile(_program.Root); return new EvaluationResult(result, _diagnostics.ToImmutableArray()); } - private MObject? EvaluateFile(FileSyntaxNode root) + private MObject? EvaluateFile(BoundFile root) { MObject? lastResult = null; - foreach (var nodeOrToken in root.StatementList) + foreach (var statement in root.Statements) { - if (nodeOrToken.IsNode) - { - var statement = (StatementSyntaxNode)nodeOrToken.AsNode()!; - lastResult = EvaluateStatement(statement) ?? lastResult; - } + lastResult = EvaluateStatement(statement) ?? lastResult; } return lastResult; } - private MObject? EvaluateStatement(StatementSyntaxNode statement) + private MObject? EvaluateStatement(BoundStatement node) { - return statement.Kind switch + return node.Kind switch { - TokenKind.AbstractMethodDeclaration => - EvaluateAbstractMethodDeclaration((AbstractMethodDeclarationSyntaxNode)statement), - TokenKind.ClassDeclaration => - EvaluateClassDeclaration((ClassDeclarationSyntaxNode)statement), - TokenKind.EmptyStatement => - EvaluateEmptyStatement((EmptyStatementSyntaxNode)statement), - TokenKind.ExpressionStatement => - EvaluateExpressionStatement((ExpressionStatementSyntaxNode)statement), - TokenKind.ForStatement => - EvaluateForStatement((ForStatementSyntaxNode)statement), - TokenKind.FunctionDeclaration => - EvaluateFunctionDeclaration((FunctionDeclarationSyntaxNode)statement), - TokenKind.IfStatement => - EvaluateIfStatement((IfStatementSyntaxNode)statement), - TokenKind.ConcreteMethodDeclaration => - EvaluateMethodDefinition((MethodDefinitionSyntaxNode)statement), - TokenKind.SwitchStatement => - EvaluateSwitchStatement((SwitchStatementSyntaxNode)statement), - TokenKind.TryCatchStatement => - EvaluateTryCatchStatement((TryCatchStatementSyntaxNode)statement), - TokenKind.WhileStatement => - EvaluateWhileStatement((WhileStatementSyntaxNode)statement), - _ => throw new NotImplementedException($"Invalid statement kind '{statement.Kind}'."), + BoundNodeKind.AbstractMethodDeclaration => + EvaluateAbstractMethodDeclaration((BoundAbstractMethodDeclaration)node), + BoundNodeKind.ClassDeclaration => + EvaluateClassDeclaration((BoundClassDeclaration)node), + BoundNodeKind.EmptyStatement => + EvaluateEmptyStatement((BoundEmptyStatement)node), + BoundNodeKind.ExpressionStatement => + EvaluateExpressionStatement((BoundExpressionStatement)node), + BoundNodeKind.ForStatement => + EvaluateForStatement((BoundForStatement)node), + BoundNodeKind.FunctionDeclaration => + EvaluateFunctionDeclaration((BoundFunctionDeclaration)node), + BoundNodeKind.IfStatement => + EvaluateIfStatement((BoundIfStatement)node), + BoundNodeKind.ConcreteMethodDeclaration => + EvaluateMethodDefinition((BoundConcreteMethodDeclaration)node), + BoundNodeKind.SwitchStatement => + EvaluateSwitchStatement((BoundSwitchStatement)node), + BoundNodeKind.TryCatchStatement => + EvaluateTryCatchStatement((BoundTryCatchStatement)node), + BoundNodeKind.WhileStatement => + EvaluateWhileStatement((BoundWhileStatement)node), + _ => throw new NotImplementedException($"Invalid statement kind '{node.Kind}'."), }; } - private MObject? EvaluateClassDeclaration(ClassDeclarationSyntaxNode statement) + private MObject? EvaluateClassDeclaration(BoundClassDeclaration node) { throw new NotImplementedException(); } - private MObject? EvaluateEmptyStatement(EmptyStatementSyntaxNode statement) + private MObject? EvaluateEmptyStatement(BoundEmptyStatement node) { throw new NotImplementedException(); } - private MObject? EvaluateTryCatchStatement(TryCatchStatementSyntaxNode statement) + private MObject? EvaluateTryCatchStatement(BoundTryCatchStatement node) { throw new NotImplementedException(); } - private MObject? EvaluateForStatement(ForStatementSyntaxNode statement) + private MObject? EvaluateForStatement(BoundForStatement node) { throw new NotImplementedException(); } - private MObject? EvaluateIfStatement(IfStatementSyntaxNode statement) + private MObject? EvaluateIfStatement(BoundIfStatement node) { throw new NotImplementedException(); } - private MObject? EvaluateWhileStatement(WhileStatementSyntaxNode statement) + private MObject? EvaluateWhileStatement(BoundWhileStatement node) { throw new NotImplementedException(); } - private MObject? EvaluateSwitchStatement(SwitchStatementSyntaxNode statement) + private MObject? EvaluateSwitchStatement(BoundSwitchStatement node) { throw new NotImplementedException(); } - private MObject? EvaluateFunctionDeclaration(FunctionDeclarationSyntaxNode statement) + private MObject? EvaluateFunctionDeclaration(BoundFunctionDeclaration node) { throw new NotImplementedException(); } - private MObject? EvaluateAbstractMethodDeclaration(AbstractMethodDeclarationSyntaxNode statement) + private MObject? EvaluateAbstractMethodDeclaration(BoundAbstractMethodDeclaration node) { throw new NotImplementedException(); } - private MObject? EvaluateMethodDefinition(MethodDefinitionSyntaxNode statement) + private MObject? EvaluateMethodDefinition(BoundConcreteMethodDeclaration node) { throw new NotImplementedException(); } - private MObject? EvaluateExpressionStatement(ExpressionStatementSyntaxNode statement) + private MObject? EvaluateExpressionStatement(BoundExpressionStatement node) { - return EvaluateExpression(statement.Expression); + return EvaluateExpression(node.Expression); } - private MObject? EvaluateExpression(ExpressionSyntaxNode expression) + private MObject? EvaluateExpression(BoundExpression node) { - return expression.Kind switch + return node.Kind switch { - TokenKind.ArrayLiteralExpression => - EvaluateArrayLiteralExpression((ArrayLiteralExpressionSyntaxNode)expression), - TokenKind.AssignmentExpression => - EvaluateAssignmentExpression((AssignmentExpressionSyntaxNode)expression), - TokenKind.BinaryOperationExpression => - EvaluateBinaryOperation((BinaryOperationExpressionSyntaxNode)expression), - TokenKind.CellArrayElementAccessExpression => - EvaluateCellArrayElementAccess((CellArrayElementAccessExpressionSyntaxNode)expression), - TokenKind.CellArrayLiteralExpression => - EvaluateCellArrayLiteralExpression((CellArrayLiteralExpressionSyntaxNode)expression), - TokenKind.ClassInvokationExpression => - EvaluateClassInvokation((BaseClassInvokationSyntaxNode)expression), - TokenKind.CommandExpression => - EvaluateCommand((CommandExpressionSyntaxNode)expression), - TokenKind.CompoundNameExpression => - EvaluateCompoundName((CompoundNameExpressionSyntaxNode)expression), - TokenKind.DoubleQuotedStringLiteralExpression => - EvaluateDoubleQuotedStringLiteralExpression((DoubleQuotedStringLiteralSyntaxNode)expression), - TokenKind.EmptyExpression => - EvaluateEmptyExpression((EmptyExpressionSyntaxNode)expression), - TokenKind.FunctionCallExpression => - EvaluateFunctionCall((FunctionCallExpressionSyntaxNode)expression), - TokenKind.IdentifierNameExpression => - EvaluateIdentifierNameExpression((IdentifierNameExpressionSyntaxNode)expression), - TokenKind.IndirectMemberAccessExpression => - EvaluateIndirectMemberAccess((IndirectMemberAccessSyntaxNode)expression), - TokenKind.LambdaExpression => - EvaluateLambdaExpression((LambdaExpressionSyntaxNode)expression), - TokenKind.MemberAccessExpression => - EvaluateMemberAccess((MemberAccessSyntaxNode)expression), - TokenKind.NamedFunctionHandleExpression => - EvaluateNamedFunctionHandleExpression((NamedFunctionHandleExpressionSyntaxNode)expression), - TokenKind.NumberLiteralExpression => - EvaluateNumberLiteralExpression((NumberLiteralSyntaxNode)expression), - TokenKind.ParenthesizedExpression => - EvaluateParenthesizedExpression((ParenthesizedExpressionSyntaxNode)expression), - TokenKind.StringLiteralExpression => - EvaluateStringLiteralExpression((StringLiteralSyntaxNode)expression), - TokenKind.UnaryPrefixOperationExpression => - EvaluateUnaryPrefixOperationExpression((UnaryPrefixOperationExpressionSyntaxNode)expression), - TokenKind.UnaryPostfixOperationExpression => - EvaluateUnaryPostfixOperationExpression((UnaryPostixOperationExpressionSyntaxNode)expression), - TokenKind.UnquotedStringLiteralExpression => - EvaluateUnquotedStringLiteralExpression((UnquotedStringLiteralSyntaxNode)expression), - _ => throw new NotImplementedException($"Invalid expression kind '{expression.Kind}'."), + BoundNodeKind.ArrayLiteralExpression => + EvaluateArrayLiteralExpression((BoundArrayLiteralExpression)node), + BoundNodeKind.AssignmentExpression => + EvaluateAssignmentExpression((BoundAssignmentExpression)node), + BoundNodeKind.BinaryOperationExpression => + EvaluateBinaryOperation((BoundBinaryOperationExpression)node), + BoundNodeKind.CellArrayElementAccessExpression => + EvaluateCellArrayElementAccess((BoundCellArrayElementAccessExpression)node), + BoundNodeKind.CellArrayLiteralExpression => + EvaluateCellArrayLiteralExpression((BoundCellArrayLiteralExpression)node), + BoundNodeKind.ClassInvokationExpression => + EvaluateClassInvokation((BoundClassInvokationExpression)node), + BoundNodeKind.CommandExpression => + EvaluateCommand((BoundCommandExpression)node), + BoundNodeKind.CompoundNameExpression => + EvaluateCompoundName((BoundCompoundNameExpression)node), + BoundNodeKind.DoubleQuotedStringLiteralExpression => + EvaluateDoubleQuotedStringLiteralExpression((BoundDoubleQuotedStringLiteralExpression)node), + BoundNodeKind.EmptyExpression => + EvaluateEmptyExpression((BoundEmptyExpression)node), + BoundNodeKind.FunctionCallExpression => + EvaluateFunctionCall((BoundFunctionCallExpression)node), + BoundNodeKind.IdentifierNameExpression => + EvaluateIdentifierNameExpression((BoundIdentifierNameExpression)node), + BoundNodeKind.IndirectMemberAccessExpression => + EvaluateIndirectMemberAccess((BoundIndirectMemberAccessExpression)node), + BoundNodeKind.LambdaExpression => + EvaluateLambdaExpression((BoundLambdaExpression)node), + BoundNodeKind.MemberAccessExpression => + EvaluateMemberAccess((BoundMemberAccessExpression)node), + BoundNodeKind.NamedFunctionHandleExpression => + EvaluateNamedFunctionHandleExpression((BoundNamedFunctionHandleExpression)node), + BoundNodeKind.NumberLiteralExpression => + EvaluateNumberLiteralExpression((BoundNumberLiteralExpression)node), + BoundNodeKind.ParenthesizedExpression => + EvaluateParenthesizedExpression((BoundParenthesizedExpression)node), + BoundNodeKind.StringLiteralExpression => + EvaluateStringLiteralExpression((BoundStringLiteralExpression)node), + BoundNodeKind.UnaryPrefixOperationExpression => + EvaluateUnaryPrefixOperationExpression((BoundUnaryPrefixOperationExpression)node), + BoundNodeKind.UnaryPostfixOperationExpression => + EvaluateUnaryPostfixOperationExpression((BoundUnaryPostfixOperationExpression)node), + BoundNodeKind.UnquotedStringLiteralExpression => + EvaluateUnquotedStringLiteralExpression((BoundUnquotedStringLiteralExpression)node), + _ => throw new NotImplementedException($"Invalid expression kind '{node.Kind}'."), }; } - private MObject? EvaluateParenthesizedExpression(ParenthesizedExpressionSyntaxNode expression) + private MObject? EvaluateParenthesizedExpression(BoundParenthesizedExpression node) { - return EvaluateExpression(expression.Expression); + return EvaluateExpression(node.Expression); } - private MObject? EvaluateClassInvokation(BaseClassInvokationSyntaxNode expression) + private MObject? EvaluateClassInvokation(BoundClassInvokationExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateCommand(CommandExpressionSyntaxNode expression) + private MObject? EvaluateCommand(BoundCommandExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateIndirectMemberAccess(IndirectMemberAccessSyntaxNode expression) + private MObject? EvaluateIndirectMemberAccess(BoundIndirectMemberAccessExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateUnaryPostfixOperationExpression(UnaryPostixOperationExpressionSyntaxNode expression) + private MObject? EvaluateUnaryPostfixOperationExpression(BoundUnaryPostfixOperationExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateMemberAccess(MemberAccessSyntaxNode expression) + private MObject? EvaluateMemberAccess(BoundMemberAccessExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateFunctionCall(FunctionCallExpressionSyntaxNode expression) + private MObject? EvaluateFunctionCall(BoundFunctionCallExpression node) { var arguments = new List(); - var nodes = expression.Nodes.Where(n => n.IsNode).Select(n => (ExpressionSyntaxNode)n.AsNode()!); var allGood = true; - foreach (var node in nodes) + foreach (var argument in node.Arguments) { - var argument = EvaluateExpression(node); + var evaluatedArgument = EvaluateExpression(argument); if (argument is null) { _diagnostics.ReportCannotEvaluateExpression( - new TextSpan(node.Position, node.FullWidth)); + new TextSpan(argument.Syntax.Position, argument.Syntax.FullWidth)); allGood = false; } else { - arguments.Add(argument); + arguments.Add(evaluatedArgument); } } @@ -237,7 +233,7 @@ namespace Parser return null; } - var function = GetFunctionSymbol(expression.FunctionName); + var function = GetFunctionSymbol(node.Name); if (function.Name == "disp") { return EvaluateDisp(arguments); @@ -256,128 +252,126 @@ namespace Parser } Console.WriteLine(arguments[0]); - return null; + return arguments[0]; } - private FunctionSymbol GetFunctionSymbol(ExpressionSyntaxNode functionName) + private FunctionSymbol GetFunctionSymbol(BoundExpression functionName) { - if (functionName.Kind == TokenKind.IdentifierNameExpression) + if (functionName.Kind == BoundNodeKind.IdentifierNameExpression) { - return new FunctionSymbol(((IdentifierNameExpressionSyntaxNode)functionName).Text); + return new FunctionSymbol(((BoundIdentifierNameExpression)functionName).Name); } - throw new NotImplementedException($"Unknown function symbol '{functionName.Text}'."); + throw new NotImplementedException($"Unknown function symbol '{functionName.Syntax.Text}'."); } - private MObject? EvaluateCellArrayElementAccess(CellArrayElementAccessExpressionSyntaxNode expression) + private MObject? EvaluateCellArrayElementAccess(BoundCellArrayElementAccessExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateCellArrayLiteralExpression(CellArrayLiteralExpressionSyntaxNode expression) + private MObject? EvaluateCellArrayLiteralExpression(BoundCellArrayLiteralExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateArrayLiteralExpression(ArrayLiteralExpressionSyntaxNode expression) + private MObject? EvaluateArrayLiteralExpression(BoundArrayLiteralExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateUnquotedStringLiteralExpression(UnquotedStringLiteralSyntaxNode expression) + private MObject? EvaluateUnquotedStringLiteralExpression(BoundUnquotedStringLiteralExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateDoubleQuotedStringLiteralExpression(DoubleQuotedStringLiteralSyntaxNode expression) + private MObject? EvaluateDoubleQuotedStringLiteralExpression(BoundDoubleQuotedStringLiteralExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateStringLiteralExpression(StringLiteralSyntaxNode expression) + private MObject? EvaluateStringLiteralExpression(BoundStringLiteralExpression node) { - return expression.StringToken.Value switch + return node.Value switch { string s => MObject.CreateCharArray(s.ToCharArray()), _ => null, }; } - private MObject? EvaluateNumberLiteralExpression(NumberLiteralSyntaxNode expression) + private MObject? EvaluateNumberLiteralExpression(BoundNumberLiteralExpression node) { - return expression.Number.Value is double value - ? MObject.CreateDoubleNumber(value) - : null; + return MObject.CreateDoubleNumber(node.Value); } - private MObject? EvaluateIdentifierNameExpression(IdentifierNameExpressionSyntaxNode expression) + private MObject? EvaluateIdentifierNameExpression(BoundIdentifierNameExpression node) { - var variableName = expression.Name.Text; + var variableName = node.Name; var maybeValue = GetVariableValue(variableName); if (maybeValue is null) { _diagnostics.ReportVariableNotFound( - new TextSpan(expression.Name.Position, expression.Name.Text.Length), + new TextSpan(node.Syntax.Position, node.Syntax.FullWidth), variableName); } return maybeValue; } - private MObject? EvaluateBinaryOperation(BinaryOperationExpressionSyntaxNode expression) + private MObject? EvaluateBinaryOperation(BoundBinaryOperationExpression node) { - var left = EvaluateExpression(expression.Lhs); + var left = EvaluateExpression(node.Left); if (left is null) { return null; } - var right = EvaluateExpression(expression.Rhs); + var right = EvaluateExpression(node.Right); if (right is null) { return null; } - return expression.Operation.Kind switch + return node.Op.Kind switch { - TokenKind.PlusToken => MOperations.Plus(left, right), - TokenKind.MinusToken => MOperations.Minus(left, right), - TokenKind.StarToken => MOperations.Star(left, right), - TokenKind.SlashToken => MOperations.Slash(left, right), - _ => throw new NotImplementedException($"Binary operation {expression.Operation.Kind} is not implemented."), + BoundBinaryOperatorKind.Plus => MOperations.Plus(left, right), + BoundBinaryOperatorKind.Minus => MOperations.Minus(left, right), + BoundBinaryOperatorKind.Star => MOperations.Star(left, right), + BoundBinaryOperatorKind.Slash => MOperations.Slash(left, right), + _ => throw new NotImplementedException($"Binary operation {node.Op.Kind} is not implemented."), }; } - private MObject? EvaluateCompoundName(CompoundNameExpressionSyntaxNode expression) + private MObject? EvaluateCompoundName(BoundCompoundNameExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateUnaryPrefixOperationExpression(UnaryPrefixOperationExpressionSyntaxNode expression) + private MObject? EvaluateUnaryPrefixOperationExpression(BoundUnaryPrefixOperationExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateEmptyExpression(EmptyExpressionSyntaxNode expression) + private MObject? EvaluateEmptyExpression(BoundEmptyExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateAssignmentExpression(AssignmentExpressionSyntaxNode expression) + private MObject? EvaluateAssignmentExpression(BoundAssignmentExpression node) { - var rightValue = EvaluateExpression(expression.Rhs); + var rightValue = EvaluateExpression(node.Right); if (rightValue is null) { _diagnostics.ReportCannotEvaluateExpression( - new TextSpan(expression.Rhs.Position, expression.Rhs.Position + expression.Rhs.FullWidth)); + new TextSpan(node.Right.Syntax.Position, node.Right.Syntax.Position + node.Right.Syntax.FullWidth)); return null; } - var left = expression.Lhs; - if (left.Kind == TokenKind.IdentifierNameExpression) + var left = node.Left; + if (left.Kind == BoundNodeKind.IdentifierNameExpression) { - var leftIdentifier = (IdentifierNameExpressionSyntaxNode)left; - var variableName = leftIdentifier.Name.Text; + var leftIdentifier = (BoundIdentifierNameExpression)left; + var variableName = leftIdentifier.Name; SetVariableValue(variableName, rightValue); return rightValue; } @@ -428,12 +422,12 @@ namespace Parser } } - private MObject? EvaluateLambdaExpression(LambdaExpressionSyntaxNode expression) + private MObject? EvaluateLambdaExpression(BoundLambdaExpression node) { throw new NotImplementedException(); } - private MObject? EvaluateNamedFunctionHandleExpression(NamedFunctionHandleExpressionSyntaxNode expression) + private MObject? EvaluateNamedFunctionHandleExpression(BoundNamedFunctionHandleExpression node) { throw new NotImplementedException(); } diff --git a/Parser/Internal/MParserGreen.cs b/Parser/Internal/MParserGreen.cs index 44587c8..3566598 100644 --- a/Parser/Internal/MParserGreen.cs +++ b/Parser/Internal/MParserGreen.cs @@ -307,13 +307,13 @@ namespace Parser.Internal switch (token.Kind) { case TokenKind.NumberLiteralToken: - expression = Factory.NumberLiteralSyntax(EatToken()); + expression = Factory.NumberLiteralExpressionSyntax(EatToken()); break; case TokenKind.StringLiteralToken: - expression = Factory.StringLiteralSyntax(EatToken()); + expression = Factory.StringLiteralExpressionSyntax(EatToken()); break; case TokenKind.DoubleQuotedStringLiteralToken: - expression = Factory.DoubleQuotedStringLiteralSyntax(EatToken()); + expression = Factory.DoubleQuotedStringLiteralExpressionSyntax(EatToken()); break; case TokenKind.OpenSquareBracketToken: expression = ParseArrayLiteral(); @@ -378,13 +378,13 @@ namespace Parser.Internal break; case TokenKind.DotToken: // member access if (expression is IdentifierNameExpressionSyntaxNode - || expression is MemberAccessSyntaxNode + || expression is MemberAccessExpressionSyntaxNode || expression is FunctionCallExpressionSyntaxNode || expression is CellArrayElementAccessExpressionSyntaxNode) { var dot = EatToken(); var member = ParseMemberAccess(); - expression = Factory.MemberAccessSyntax(expression, dot, member); + expression = Factory.MemberAccessExpressionSyntax(expression, dot, member); } else { @@ -396,7 +396,7 @@ namespace Parser.Internal case TokenKind.ApostropheToken: case TokenKind.DotApostropheToken: var operation = EatToken(); - expression = Factory.UnaryPostixOperationExpressionSyntax(expression, operation); + expression = Factory.UnaryPostfixOperationExpressionSyntax(expression, operation); break; case TokenKind.UnquotedStringLiteralToken: return ParseCommandExpression(expression); @@ -416,10 +416,10 @@ namespace Parser.Internal { if (expression is IdentifierNameExpressionSyntaxNode idNameNode) { - var builder = new SyntaxListBuilder(); + var builder = new SyntaxListBuilder(); while (CurrentToken.Kind == TokenKind.UnquotedStringLiteralToken) { - builder.Add(Factory.UnquotedStringLiteralSyntax(EatToken())); + builder.Add(Factory.UnquotedStringLiteralExpressionSyntax(EatToken())); } return Factory.CommandExpressionSyntax(idNameNode._name, builder.ToList()); @@ -432,7 +432,7 @@ namespace Parser.Internal throw new ParsingException($"Unexpected token \"{CurrentToken}\" while parsing expression \"{expression.FullText}\" at {CurrentPosition}."); } - private BaseClassInvokationSyntaxNode ParseBaseClassInvokation(ExpressionSyntaxNode expression) + private ClassInvokationExpressionSyntaxNode ParseBaseClassInvokation(ExpressionSyntaxNode expression) { if (expression is IdentifierNameExpressionSyntaxNode methodName && !expression.TrailingTrivia.Any()) @@ -443,9 +443,9 @@ namespace Parser.Internal { throw new Exception($"Base class name cannot be empty."); } - return Factory.BaseClassInvokationSyntax(methodName, atToken, baseClassNameWithArguments); + return Factory.ClassInvokationExpressionSyntax(methodName, atToken, baseClassNameWithArguments); } - if (expression is MemberAccessSyntaxNode memberAccess + if (expression is MemberAccessExpressionSyntaxNode memberAccess && !expression.TrailingTrivia.Any()) { var atToken = EatToken(); @@ -454,7 +454,7 @@ namespace Parser.Internal { throw new Exception($"Base class name cannot be empty."); } - return Factory.BaseClassInvokationSyntax(memberAccess, atToken, baseClassNameWithArguments); + return Factory.ClassInvokationExpressionSyntax(memberAccess, atToken, baseClassNameWithArguments); } throw new ParsingException($"Unexpected token \"{CurrentToken}\" at {CurrentPosition}."); } @@ -474,7 +474,7 @@ namespace Parser.Internal throw new Exception("Indirect member invokation cannot be empty."); } var closingBracket = EatToken(TokenKind.CloseParenthesisToken); - return Factory.IndirectMemberAccessSyntax( + return Factory.IndirectMemberAccessExpressionSyntax( openingBracket, indirectMember, closingBracket); @@ -920,7 +920,7 @@ namespace Parser.Internal throw new ParsingException($"Unexpected token {CurrentToken} while parsing method declaration at {CurrentPosition}."); } - private MethodDefinitionSyntaxNode ParseMethodDefinition() + private ConcreteMethodDeclarationSyntaxNode ParseMethodDefinition() { var functionKeyword = EatIdentifier("function"); var outputDescription = ParseFunctionOutputDescription(); @@ -929,7 +929,7 @@ namespace Parser.Internal var commas = ParseOptionalCommas(); var body = ParseStatementList(); var endKeyword = ParseEndKeyword(); - return Factory.MethodDefinitionSyntax( + return Factory.ConcreteMethodDeclarationSyntax( functionKeyword, outputDescription, name, diff --git a/Parser/Internal/SyntaxFactory.Generated.cs b/Parser/Internal/SyntaxFactory.Generated.cs index 393bcbe..709f01b 100644 --- a/Parser/Internal/SyntaxFactory.Generated.cs +++ b/Parser/Internal/SyntaxFactory.Generated.cs @@ -118,24 +118,24 @@ namespace Parser.Internal return new IdentifierNameExpressionSyntaxNode(name); } - public NumberLiteralSyntaxNode NumberLiteralSyntax(SyntaxToken number) + public NumberLiteralExpressionSyntaxNode NumberLiteralExpressionSyntax(SyntaxToken number) { - return new NumberLiteralSyntaxNode(number); + return new NumberLiteralExpressionSyntaxNode(number); } - public StringLiteralSyntaxNode StringLiteralSyntax(SyntaxToken stringToken) + public StringLiteralExpressionSyntaxNode StringLiteralExpressionSyntax(SyntaxToken stringToken) { - return new StringLiteralSyntaxNode(stringToken); + return new StringLiteralExpressionSyntaxNode(stringToken); } - public DoubleQuotedStringLiteralSyntaxNode DoubleQuotedStringLiteralSyntax(SyntaxToken stringToken) + public DoubleQuotedStringLiteralExpressionSyntaxNode DoubleQuotedStringLiteralExpressionSyntax(SyntaxToken stringToken) { - return new DoubleQuotedStringLiteralSyntaxNode(stringToken); + return new DoubleQuotedStringLiteralExpressionSyntaxNode(stringToken); } - public UnquotedStringLiteralSyntaxNode UnquotedStringLiteralSyntax(SyntaxToken stringToken) + public UnquotedStringLiteralExpressionSyntaxNode UnquotedStringLiteralExpressionSyntax(SyntaxToken stringToken) { - return new UnquotedStringLiteralSyntaxNode(stringToken); + return new UnquotedStringLiteralExpressionSyntaxNode(stringToken); } public ArrayLiteralExpressionSyntaxNode ArrayLiteralExpressionSyntax(SyntaxToken openingSquareBracket, SyntaxList nodes, SyntaxToken closingSquareBracket) @@ -163,29 +163,29 @@ namespace Parser.Internal return new FunctionCallExpressionSyntaxNode(functionName, openingBracket, nodes, closingBracket); } - public MemberAccessSyntaxNode MemberAccessSyntax(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand) + public MemberAccessExpressionSyntaxNode MemberAccessExpressionSyntax(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand) { - return new MemberAccessSyntaxNode(leftOperand, dot, rightOperand); + return new MemberAccessExpressionSyntaxNode(leftOperand, dot, rightOperand); } - public UnaryPostixOperationExpressionSyntaxNode UnaryPostixOperationExpressionSyntax(ExpressionSyntaxNode operand, SyntaxToken operation) + public UnaryPostfixOperationExpressionSyntaxNode UnaryPostfixOperationExpressionSyntax(ExpressionSyntaxNode operand, SyntaxToken operation) { - return new UnaryPostixOperationExpressionSyntaxNode(operand, operation); + return new UnaryPostfixOperationExpressionSyntaxNode(operand, operation); } - public IndirectMemberAccessSyntaxNode IndirectMemberAccessSyntax(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket) + public IndirectMemberAccessExpressionSyntaxNode IndirectMemberAccessExpressionSyntax(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket) { - return new IndirectMemberAccessSyntaxNode(openingBracket, expression, closingBracket); + return new IndirectMemberAccessExpressionSyntaxNode(openingBracket, expression, closingBracket); } - public CommandExpressionSyntaxNode CommandExpressionSyntax(SyntaxToken commandName, SyntaxList arguments) + public CommandExpressionSyntaxNode CommandExpressionSyntax(SyntaxToken commandName, SyntaxList arguments) { return new CommandExpressionSyntaxNode(commandName, arguments); } - public BaseClassInvokationSyntaxNode BaseClassInvokationSyntax(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments) + public ClassInvokationExpressionSyntaxNode ClassInvokationExpressionSyntax(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments) { - return new BaseClassInvokationSyntaxNode(methodName, atSign, baseClassNameAndArguments); + return new ClassInvokationExpressionSyntaxNode(methodName, atSign, baseClassNameAndArguments); } public AttributeAssignmentSyntaxNode AttributeAssignmentSyntax(SyntaxToken assignmentSign, ExpressionSyntaxNode value) @@ -203,9 +203,9 @@ namespace Parser.Internal return new AttributeListSyntaxNode(openingBracket, nodes, closingBracket); } - public MethodDefinitionSyntaxNode MethodDefinitionSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword) + public ConcreteMethodDeclarationSyntaxNode ConcreteMethodDeclarationSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword) { - return new MethodDefinitionSyntaxNode(functionKeyword, outputDescription, name, inputDescription, commas, body, endKeyword); + return new ConcreteMethodDeclarationSyntaxNode(functionKeyword, outputDescription, name, inputDescription, commas, body, endKeyword); } public AbstractMethodDeclarationSyntaxNode AbstractMethodDeclarationSyntax(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription) diff --git a/Parser/Internal/SyntaxNode.Generated.cs b/Parser/Internal/SyntaxNode.Generated.cs index fcf0d13..b556632 100644 --- a/Parser/Internal/SyntaxNode.Generated.cs +++ b/Parser/Internal/SyntaxNode.Generated.cs @@ -1105,17 +1105,17 @@ namespace Parser.Internal } } - internal class NumberLiteralSyntaxNode : ExpressionSyntaxNode + internal class NumberLiteralExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _number; - internal NumberLiteralSyntaxNode(SyntaxToken number): base(TokenKind.NumberLiteralExpression) + internal NumberLiteralExpressionSyntaxNode(SyntaxToken number): base(TokenKind.NumberLiteralExpression) { Slots = 1; this.AdjustWidth(number); _number = number; } - internal NumberLiteralSyntaxNode(SyntaxToken number, TokenDiagnostic[] diagnostics): base(TokenKind.NumberLiteralExpression, diagnostics) + internal NumberLiteralExpressionSyntaxNode(SyntaxToken number, TokenDiagnostic[] diagnostics): base(TokenKind.NumberLiteralExpression, diagnostics) { Slots = 1; this.AdjustWidth(number); @@ -1124,12 +1124,12 @@ namespace Parser.Internal internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { - return new Parser.NumberLiteralSyntaxNode(parent, this, position); + return new Parser.NumberLiteralExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { - return new NumberLiteralSyntaxNode(_number, diagnostics); + return new NumberLiteralExpressionSyntaxNode(_number, diagnostics); } public override GreenNode? GetSlot(int i) @@ -1143,17 +1143,17 @@ namespace Parser.Internal } } - internal class StringLiteralSyntaxNode : ExpressionSyntaxNode + internal class StringLiteralExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _stringToken; - internal StringLiteralSyntaxNode(SyntaxToken stringToken): base(TokenKind.StringLiteralExpression) + internal StringLiteralExpressionSyntaxNode(SyntaxToken stringToken): base(TokenKind.StringLiteralExpression) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } - internal StringLiteralSyntaxNode(SyntaxToken stringToken, TokenDiagnostic[] diagnostics): base(TokenKind.StringLiteralExpression, diagnostics) + internal StringLiteralExpressionSyntaxNode(SyntaxToken stringToken, TokenDiagnostic[] diagnostics): base(TokenKind.StringLiteralExpression, diagnostics) { Slots = 1; this.AdjustWidth(stringToken); @@ -1162,12 +1162,12 @@ namespace Parser.Internal internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { - return new Parser.StringLiteralSyntaxNode(parent, this, position); + return new Parser.StringLiteralExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { - return new StringLiteralSyntaxNode(_stringToken, diagnostics); + return new StringLiteralExpressionSyntaxNode(_stringToken, diagnostics); } public override GreenNode? GetSlot(int i) @@ -1181,17 +1181,17 @@ namespace Parser.Internal } } - internal class DoubleQuotedStringLiteralSyntaxNode : ExpressionSyntaxNode + internal class DoubleQuotedStringLiteralExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _stringToken; - internal DoubleQuotedStringLiteralSyntaxNode(SyntaxToken stringToken): base(TokenKind.DoubleQuotedStringLiteralExpression) + internal DoubleQuotedStringLiteralExpressionSyntaxNode(SyntaxToken stringToken): base(TokenKind.DoubleQuotedStringLiteralExpression) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } - internal DoubleQuotedStringLiteralSyntaxNode(SyntaxToken stringToken, TokenDiagnostic[] diagnostics): base(TokenKind.DoubleQuotedStringLiteralExpression, diagnostics) + internal DoubleQuotedStringLiteralExpressionSyntaxNode(SyntaxToken stringToken, TokenDiagnostic[] diagnostics): base(TokenKind.DoubleQuotedStringLiteralExpression, diagnostics) { Slots = 1; this.AdjustWidth(stringToken); @@ -1200,12 +1200,12 @@ namespace Parser.Internal internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { - return new Parser.DoubleQuotedStringLiteralSyntaxNode(parent, this, position); + return new Parser.DoubleQuotedStringLiteralExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { - return new DoubleQuotedStringLiteralSyntaxNode(_stringToken, diagnostics); + return new DoubleQuotedStringLiteralExpressionSyntaxNode(_stringToken, diagnostics); } public override GreenNode? GetSlot(int i) @@ -1219,17 +1219,17 @@ namespace Parser.Internal } } - internal class UnquotedStringLiteralSyntaxNode : ExpressionSyntaxNode + internal class UnquotedStringLiteralExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _stringToken; - internal UnquotedStringLiteralSyntaxNode(SyntaxToken stringToken): base(TokenKind.UnquotedStringLiteralExpression) + internal UnquotedStringLiteralExpressionSyntaxNode(SyntaxToken stringToken): base(TokenKind.UnquotedStringLiteralExpression) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } - internal UnquotedStringLiteralSyntaxNode(SyntaxToken stringToken, TokenDiagnostic[] diagnostics): base(TokenKind.UnquotedStringLiteralExpression, diagnostics) + internal UnquotedStringLiteralExpressionSyntaxNode(SyntaxToken stringToken, TokenDiagnostic[] diagnostics): base(TokenKind.UnquotedStringLiteralExpression, diagnostics) { Slots = 1; this.AdjustWidth(stringToken); @@ -1238,12 +1238,12 @@ namespace Parser.Internal internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { - return new Parser.UnquotedStringLiteralSyntaxNode(parent, this, position); + return new Parser.UnquotedStringLiteralExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { - return new UnquotedStringLiteralSyntaxNode(_stringToken, diagnostics); + return new UnquotedStringLiteralExpressionSyntaxNode(_stringToken, diagnostics); } public override GreenNode? GetSlot(int i) @@ -1507,12 +1507,12 @@ namespace Parser.Internal } } - internal class MemberAccessSyntaxNode : ExpressionSyntaxNode + internal class MemberAccessExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxNode _leftOperand; internal readonly SyntaxToken _dot; internal readonly SyntaxNode _rightOperand; - internal MemberAccessSyntaxNode(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand): base(TokenKind.MemberAccessExpression) + internal MemberAccessExpressionSyntaxNode(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand): base(TokenKind.MemberAccessExpression) { Slots = 3; this.AdjustWidth(leftOperand); @@ -1523,7 +1523,7 @@ namespace Parser.Internal _rightOperand = rightOperand; } - internal MemberAccessSyntaxNode(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand, TokenDiagnostic[] diagnostics): base(TokenKind.MemberAccessExpression, diagnostics) + internal MemberAccessExpressionSyntaxNode(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand, TokenDiagnostic[] diagnostics): base(TokenKind.MemberAccessExpression, diagnostics) { Slots = 3; this.AdjustWidth(leftOperand); @@ -1536,12 +1536,12 @@ namespace Parser.Internal internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { - return new Parser.MemberAccessSyntaxNode(parent, this, position); + return new Parser.MemberAccessExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { - return new MemberAccessSyntaxNode(_leftOperand, _dot, _rightOperand, diagnostics); + return new MemberAccessExpressionSyntaxNode(_leftOperand, _dot, _rightOperand, diagnostics); } public override GreenNode? GetSlot(int i) @@ -1555,11 +1555,11 @@ namespace Parser.Internal } } - internal class UnaryPostixOperationExpressionSyntaxNode : ExpressionSyntaxNode + internal class UnaryPostfixOperationExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly ExpressionSyntaxNode _operand; internal readonly SyntaxToken _operation; - internal UnaryPostixOperationExpressionSyntaxNode(ExpressionSyntaxNode operand, SyntaxToken operation): base(TokenKind.UnaryPostfixOperationExpression) + internal UnaryPostfixOperationExpressionSyntaxNode(ExpressionSyntaxNode operand, SyntaxToken operation): base(TokenKind.UnaryPostfixOperationExpression) { Slots = 2; this.AdjustWidth(operand); @@ -1568,7 +1568,7 @@ namespace Parser.Internal _operation = operation; } - internal UnaryPostixOperationExpressionSyntaxNode(ExpressionSyntaxNode operand, SyntaxToken operation, TokenDiagnostic[] diagnostics): base(TokenKind.UnaryPostfixOperationExpression, diagnostics) + internal UnaryPostfixOperationExpressionSyntaxNode(ExpressionSyntaxNode operand, SyntaxToken operation, TokenDiagnostic[] diagnostics): base(TokenKind.UnaryPostfixOperationExpression, diagnostics) { Slots = 2; this.AdjustWidth(operand); @@ -1579,12 +1579,12 @@ namespace Parser.Internal internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { - return new Parser.UnaryPostixOperationExpressionSyntaxNode(parent, this, position); + return new Parser.UnaryPostfixOperationExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { - return new UnaryPostixOperationExpressionSyntaxNode(_operand, _operation, diagnostics); + return new UnaryPostfixOperationExpressionSyntaxNode(_operand, _operation, diagnostics); } public override GreenNode? GetSlot(int i) @@ -1598,12 +1598,12 @@ namespace Parser.Internal } } - internal class IndirectMemberAccessSyntaxNode : ExpressionSyntaxNode + internal class IndirectMemberAccessExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _openingBracket; internal readonly ExpressionSyntaxNode _expression; internal readonly SyntaxToken _closingBracket; - internal IndirectMemberAccessSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket): base(TokenKind.IndirectMemberAccessExpression) + internal IndirectMemberAccessExpressionSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket): base(TokenKind.IndirectMemberAccessExpression) { Slots = 3; this.AdjustWidth(openingBracket); @@ -1614,7 +1614,7 @@ namespace Parser.Internal _closingBracket = closingBracket; } - internal IndirectMemberAccessSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.IndirectMemberAccessExpression, diagnostics) + internal IndirectMemberAccessExpressionSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.IndirectMemberAccessExpression, diagnostics) { Slots = 3; this.AdjustWidth(openingBracket); @@ -1627,12 +1627,12 @@ namespace Parser.Internal internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { - return new Parser.IndirectMemberAccessSyntaxNode(parent, this, position); + return new Parser.IndirectMemberAccessExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { - return new IndirectMemberAccessSyntaxNode(_openingBracket, _expression, _closingBracket, diagnostics); + return new IndirectMemberAccessExpressionSyntaxNode(_openingBracket, _expression, _closingBracket, diagnostics); } public override GreenNode? GetSlot(int i) @@ -1649,8 +1649,8 @@ namespace Parser.Internal internal class CommandExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _commandName; - internal readonly SyntaxList _arguments; - internal CommandExpressionSyntaxNode(SyntaxToken commandName, SyntaxList arguments): base(TokenKind.CommandExpression) + internal readonly SyntaxList _arguments; + internal CommandExpressionSyntaxNode(SyntaxToken commandName, SyntaxList arguments): base(TokenKind.CommandExpression) { Slots = 2; this.AdjustWidth(commandName); @@ -1659,7 +1659,7 @@ namespace Parser.Internal _arguments = arguments; } - internal CommandExpressionSyntaxNode(SyntaxToken commandName, SyntaxList arguments, TokenDiagnostic[] diagnostics): base(TokenKind.CommandExpression, diagnostics) + internal CommandExpressionSyntaxNode(SyntaxToken commandName, SyntaxList arguments, TokenDiagnostic[] diagnostics): base(TokenKind.CommandExpression, diagnostics) { Slots = 2; this.AdjustWidth(commandName); @@ -1689,12 +1689,12 @@ namespace Parser.Internal } } - internal class BaseClassInvokationSyntaxNode : ExpressionSyntaxNode + internal class ClassInvokationExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly ExpressionSyntaxNode _methodName; internal readonly SyntaxToken _atSign; internal readonly ExpressionSyntaxNode _baseClassNameAndArguments; - internal BaseClassInvokationSyntaxNode(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments): base(TokenKind.ClassInvokationExpression) + internal ClassInvokationExpressionSyntaxNode(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments): base(TokenKind.ClassInvokationExpression) { Slots = 3; this.AdjustWidth(methodName); @@ -1705,7 +1705,7 @@ namespace Parser.Internal _baseClassNameAndArguments = baseClassNameAndArguments; } - internal BaseClassInvokationSyntaxNode(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments, TokenDiagnostic[] diagnostics): base(TokenKind.ClassInvokationExpression, diagnostics) + internal ClassInvokationExpressionSyntaxNode(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments, TokenDiagnostic[] diagnostics): base(TokenKind.ClassInvokationExpression, diagnostics) { Slots = 3; this.AdjustWidth(methodName); @@ -1718,12 +1718,12 @@ namespace Parser.Internal internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { - return new Parser.BaseClassInvokationSyntaxNode(parent, this, position); + return new Parser.ClassInvokationExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { - return new BaseClassInvokationSyntaxNode(_methodName, _atSign, _baseClassNameAndArguments, diagnostics); + return new ClassInvokationExpressionSyntaxNode(_methodName, _atSign, _baseClassNameAndArguments, diagnostics); } public override GreenNode? GetSlot(int i) @@ -1871,7 +1871,7 @@ namespace Parser.Internal } } - internal class MethodDefinitionSyntaxNode : MethodDeclarationSyntaxNode + internal class ConcreteMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode { internal readonly SyntaxToken _functionKeyword; internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription; @@ -1880,7 +1880,7 @@ namespace Parser.Internal internal readonly SyntaxList _commas; internal readonly SyntaxList _body; internal readonly EndKeywordSyntaxNode? _endKeyword; - internal MethodDefinitionSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.ConcreteMethodDeclaration) + internal ConcreteMethodDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.ConcreteMethodDeclaration) { Slots = 7; this.AdjustWidth(functionKeyword); @@ -1899,7 +1899,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal MethodDefinitionSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ConcreteMethodDeclaration, diagnostics) + internal ConcreteMethodDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ConcreteMethodDeclaration, diagnostics) { Slots = 7; this.AdjustWidth(functionKeyword); @@ -1920,12 +1920,12 @@ namespace Parser.Internal internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { - return new Parser.MethodDefinitionSyntaxNode(parent, this, position); + return new Parser.ConcreteMethodDeclarationSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { - return new MethodDefinitionSyntaxNode(_functionKeyword, _outputDescription, _name, _inputDescription, _commas, _body, _endKeyword, diagnostics); + return new ConcreteMethodDeclarationSyntaxNode(_functionKeyword, _outputDescription, _name, _inputDescription, _commas, _body, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) diff --git a/Parser/SyntaxDefinition.xml b/Parser/SyntaxDefinition.xml index 81c1532..de938f6 100644 --- a/Parser/SyntaxDefinition.xml +++ b/Parser/SyntaxDefinition.xml @@ -115,16 +115,16 @@ - + - + - + - + @@ -154,25 +154,25 @@ - + - + - + - + - + @@ -190,7 +190,7 @@ - + diff --git a/Parser/SyntaxNode.Generated.cs b/Parser/SyntaxNode.Generated.cs index 3ac4d57..fa7b896 100644 --- a/Parser/SyntaxNode.Generated.cs +++ b/Parser/SyntaxNode.Generated.cs @@ -1143,9 +1143,9 @@ namespace Parser } } - public class NumberLiteralSyntaxNode : ExpressionSyntaxNode + public class NumberLiteralExpressionSyntaxNode : ExpressionSyntaxNode { - internal NumberLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) + internal NumberLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } @@ -1153,7 +1153,7 @@ namespace Parser { get { - return new SyntaxToken(this, ((Parser.Internal.NumberLiteralSyntaxNode)_green)._number, this.GetChildPosition(0)); + return new SyntaxToken(this, ((Parser.Internal.NumberLiteralExpressionSyntaxNode)_green)._number, this.GetChildPosition(0)); } } @@ -1169,13 +1169,13 @@ namespace Parser public override void Accept(SyntaxVisitor visitor) { - visitor.VisitNumberLiteral(this); + visitor.VisitNumberLiteralExpression(this); } } - public class StringLiteralSyntaxNode : ExpressionSyntaxNode + public class StringLiteralExpressionSyntaxNode : ExpressionSyntaxNode { - internal StringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) + internal StringLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } @@ -1183,7 +1183,7 @@ namespace Parser { get { - return new SyntaxToken(this, ((Parser.Internal.StringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); + return new SyntaxToken(this, ((Parser.Internal.StringLiteralExpressionSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); } } @@ -1199,13 +1199,13 @@ namespace Parser public override void Accept(SyntaxVisitor visitor) { - visitor.VisitStringLiteral(this); + visitor.VisitStringLiteralExpression(this); } } - public class DoubleQuotedStringLiteralSyntaxNode : ExpressionSyntaxNode + public class DoubleQuotedStringLiteralExpressionSyntaxNode : ExpressionSyntaxNode { - internal DoubleQuotedStringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) + internal DoubleQuotedStringLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } @@ -1213,7 +1213,7 @@ namespace Parser { get { - return new SyntaxToken(this, ((Parser.Internal.DoubleQuotedStringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); + return new SyntaxToken(this, ((Parser.Internal.DoubleQuotedStringLiteralExpressionSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); } } @@ -1229,13 +1229,13 @@ namespace Parser public override void Accept(SyntaxVisitor visitor) { - visitor.VisitDoubleQuotedStringLiteral(this); + visitor.VisitDoubleQuotedStringLiteralExpression(this); } } - public class UnquotedStringLiteralSyntaxNode : ExpressionSyntaxNode + public class UnquotedStringLiteralExpressionSyntaxNode : ExpressionSyntaxNode { - internal UnquotedStringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) + internal UnquotedStringLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } @@ -1243,7 +1243,7 @@ namespace Parser { get { - return new SyntaxToken(this, ((Parser.Internal.UnquotedStringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); + return new SyntaxToken(this, ((Parser.Internal.UnquotedStringLiteralExpressionSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); } } @@ -1259,7 +1259,7 @@ namespace Parser public override void Accept(SyntaxVisitor visitor) { - visitor.VisitUnquotedStringLiteral(this); + visitor.VisitUnquotedStringLiteralExpression(this); } } @@ -1523,11 +1523,11 @@ namespace Parser } } - public class MemberAccessSyntaxNode : ExpressionSyntaxNode + public class MemberAccessExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _leftOperand; private SyntaxNode? _rightOperand; - internal MemberAccessSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) + internal MemberAccessExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } @@ -1535,7 +1535,7 @@ namespace Parser { get { - return new SyntaxToken(this, ((Parser.Internal.MemberAccessSyntaxNode)_green)._dot, this.GetChildPosition(1)); + return new SyntaxToken(this, ((Parser.Internal.MemberAccessExpressionSyntaxNode)_green)._dot, this.GetChildPosition(1)); } } @@ -1569,14 +1569,14 @@ namespace Parser public override void Accept(SyntaxVisitor visitor) { - visitor.VisitMemberAccess(this); + visitor.VisitMemberAccessExpression(this); } } - public class UnaryPostixOperationExpressionSyntaxNode : ExpressionSyntaxNode + public class UnaryPostfixOperationExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _operand; - internal UnaryPostixOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) + internal UnaryPostfixOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } @@ -1584,7 +1584,7 @@ namespace Parser { get { - return new SyntaxToken(this, ((Parser.Internal.UnaryPostixOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(1)); + return new SyntaxToken(this, ((Parser.Internal.UnaryPostfixOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(1)); } } @@ -1609,14 +1609,14 @@ namespace Parser public override void Accept(SyntaxVisitor visitor) { - visitor.VisitUnaryPostixOperationExpression(this); + visitor.VisitUnaryPostfixOperationExpression(this); } } - public class IndirectMemberAccessSyntaxNode : ExpressionSyntaxNode + public class IndirectMemberAccessExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _expression; - internal IndirectMemberAccessSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) + internal IndirectMemberAccessExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } @@ -1624,7 +1624,7 @@ namespace Parser { get { - return new SyntaxToken(this, ((Parser.Internal.IndirectMemberAccessSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); + return new SyntaxToken(this, ((Parser.Internal.IndirectMemberAccessExpressionSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); } } @@ -1632,7 +1632,7 @@ namespace Parser { get { - return new SyntaxToken(this, ((Parser.Internal.IndirectMemberAccessSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); + return new SyntaxToken(this, ((Parser.Internal.IndirectMemberAccessExpressionSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); } } @@ -1657,7 +1657,7 @@ namespace Parser public override void Accept(SyntaxVisitor visitor) { - visitor.VisitIndirectMemberAccess(this); + visitor.VisitIndirectMemberAccessExpression(this); } } @@ -1701,11 +1701,11 @@ namespace Parser } } - public class BaseClassInvokationSyntaxNode : ExpressionSyntaxNode + public class ClassInvokationExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _methodName; private SyntaxNode? _baseClassNameAndArguments; - internal BaseClassInvokationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) + internal ClassInvokationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } @@ -1713,7 +1713,7 @@ namespace Parser { get { - return new SyntaxToken(this, ((Parser.Internal.BaseClassInvokationSyntaxNode)_green)._atSign, this.GetChildPosition(1)); + return new SyntaxToken(this, ((Parser.Internal.ClassInvokationExpressionSyntaxNode)_green)._atSign, this.GetChildPosition(1)); } } @@ -1747,7 +1747,7 @@ namespace Parser public override void Accept(SyntaxVisitor visitor) { - visitor.VisitBaseClassInvokation(this); + visitor.VisitClassInvokationExpression(this); } } @@ -1879,7 +1879,7 @@ namespace Parser } } - public class MethodDefinitionSyntaxNode : MethodDeclarationSyntaxNode + public class ConcreteMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode { private SyntaxNode? _outputDescription; private SyntaxNode? _name; @@ -1887,7 +1887,7 @@ namespace Parser private SyntaxNode? _commas; private SyntaxNode? _body; private SyntaxNode? _endKeyword; - internal MethodDefinitionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) + internal ConcreteMethodDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } @@ -1895,7 +1895,7 @@ namespace Parser { get { - return new SyntaxToken(this, ((Parser.Internal.MethodDefinitionSyntaxNode)_green)._functionKeyword, this.GetChildPosition(0)); + return new SyntaxToken(this, ((Parser.Internal.ConcreteMethodDeclarationSyntaxNode)_green)._functionKeyword, this.GetChildPosition(0)); } } @@ -1965,7 +1965,7 @@ namespace Parser public override void Accept(SyntaxVisitor visitor) { - visitor.VisitMethodDefinition(this); + visitor.VisitConcreteMethodDeclaration(this); } } diff --git a/Parser/SyntaxVisitor.Generated.cs b/Parser/SyntaxVisitor.Generated.cs index b16d17b..d023690 100644 --- a/Parser/SyntaxVisitor.Generated.cs +++ b/Parser/SyntaxVisitor.Generated.cs @@ -118,22 +118,22 @@ namespace Parser DefaultVisit(node); } - public virtual void VisitNumberLiteral(NumberLiteralSyntaxNode node) + public virtual void VisitNumberLiteralExpression(NumberLiteralExpressionSyntaxNode node) { DefaultVisit(node); } - public virtual void VisitStringLiteral(StringLiteralSyntaxNode node) + public virtual void VisitStringLiteralExpression(StringLiteralExpressionSyntaxNode node) { DefaultVisit(node); } - public virtual void VisitDoubleQuotedStringLiteral(DoubleQuotedStringLiteralSyntaxNode node) + public virtual void VisitDoubleQuotedStringLiteralExpression(DoubleQuotedStringLiteralExpressionSyntaxNode node) { DefaultVisit(node); } - public virtual void VisitUnquotedStringLiteral(UnquotedStringLiteralSyntaxNode node) + public virtual void VisitUnquotedStringLiteralExpression(UnquotedStringLiteralExpressionSyntaxNode node) { DefaultVisit(node); } @@ -163,17 +163,17 @@ namespace Parser DefaultVisit(node); } - public virtual void VisitMemberAccess(MemberAccessSyntaxNode node) + public virtual void VisitMemberAccessExpression(MemberAccessExpressionSyntaxNode node) { DefaultVisit(node); } - public virtual void VisitUnaryPostixOperationExpression(UnaryPostixOperationExpressionSyntaxNode node) + public virtual void VisitUnaryPostfixOperationExpression(UnaryPostfixOperationExpressionSyntaxNode node) { DefaultVisit(node); } - public virtual void VisitIndirectMemberAccess(IndirectMemberAccessSyntaxNode node) + public virtual void VisitIndirectMemberAccessExpression(IndirectMemberAccessExpressionSyntaxNode node) { DefaultVisit(node); } @@ -183,7 +183,7 @@ namespace Parser DefaultVisit(node); } - public virtual void VisitBaseClassInvokation(BaseClassInvokationSyntaxNode node) + public virtual void VisitClassInvokationExpression(ClassInvokationExpressionSyntaxNode node) { DefaultVisit(node); } @@ -203,7 +203,7 @@ namespace Parser DefaultVisit(node); } - public virtual void VisitMethodDefinition(MethodDefinitionSyntaxNode node) + public virtual void VisitConcreteMethodDeclaration(ConcreteMethodDeclarationSyntaxNode node) { DefaultVisit(node); } diff --git a/Repl/MRepl.cs b/Repl/MRepl.cs index 3edfe38..ed902d0 100644 --- a/Repl/MRepl.cs +++ b/Repl/MRepl.cs @@ -1,4 +1,5 @@ using System; +using System.Linq; using Parser; namespace Repl @@ -50,8 +51,7 @@ namespace Repl private string Evaluate(string submission) { var tree = SyntaxTree.Parse(submission); - var compilation = Compilation.Create(tree); - if (tree.Diagnostics.Diagnostics.Count > 0) + if (tree.Diagnostics.Any()) { foreach (var diagnostic in tree.Diagnostics.Diagnostics) { @@ -64,7 +64,7 @@ namespace Repl } TreeRenderer.RenderTree(tree); - + var compilation = Compilation.Create(tree); var evaluationResult = compilation.Evaluate(_context); foreach (var diagnostic in evaluationResult.Diagnostics) diff --git a/Semantics/GetClass.cs b/Semantics/GetClass.cs index d9c31c1..15cb673 100644 --- a/Semantics/GetClass.cs +++ b/Semantics/GetClass.cs @@ -7,7 +7,7 @@ namespace Semantics { public class GetClass { - private static MMethod MethodFromDefinition(MethodDefinitionSyntaxNode methodDefinition) + private static MMethod MethodFromDefinition(ConcreteMethodDeclarationSyntaxNode methodDefinition) { var name = methodDefinition.Name.Text; var description = ""; @@ -42,7 +42,7 @@ namespace Semantics continue; } - if (method.AsNode() is MethodDefinitionSyntaxNode methodDefinition) + if (method.AsNode() is ConcreteMethodDeclarationSyntaxNode methodDefinition) { result.Add(MethodFromDefinition(methodDefinition)); } diff --git a/examples/helloworld/hello.m b/examples/helloworld/hello.m index 51c6bb1..9a79ec4 100644 --- a/examples/helloworld/hello.m +++ b/examples/helloworld/hello.m @@ -1,3 +1,13 @@ -x = 1; -disp(x + 2); +x = 2; +y = 3; +disp(x + y * y); disp('Hello world!'); + +% x = 2 * 3; +% if x > 5 +% y = 3; +% else +% y = 10; +% end +% +% disp(y);