Introduce binding

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;
         }
 

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);

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;
         }

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);

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<BoundElseIfClause>();
+            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<BoundStatement> BindStatementList(SyntaxNodeOrTokenList list)
+        {
+            var builder = ImmutableArray.CreateBuilder<BoundStatement>();
+            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<BoundExpression> BindExpressionList(SyntaxNodeOrTokenList list)
+        {
+            var builder = ImmutableArray.CreateBuilder<BoundExpression>();
+            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());
+        }
+    }
+}

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<Diagnostic> diagnostics)
+        {
+            NullRoot = nullRoot;
+            Diagnostics = diagnostics;
+        }
+
+        public ImmutableArray<Diagnostic> Diagnostics { get; }
+
+        public BoundRoot NullRoot { get; }
+
+        public BoundFile Root => NullRoot.File;
+    }
+}

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<BoundStatement> statements)
+            : base(syntax)
+        {
+            Statements = statements;
+        }
+
+        public ImmutableArray<BoundStatement> 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<BoundStatement> body, IEnumerable<ElseifClause> elseIfClauses, BoundElseClause? elseClause)
+            : base(syntax)
+        {
+            Condition = condition;
+            Body = body;
+            ElseIfClauses = elseIfClauses;
+            ElseClause = elseClause;
+        }
+
+        public BoundExpression Condition { get; }
+        public ImmutableArray<BoundStatement> Body { get; }
+        public IEnumerable<ElseifClause> 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<BoundExpression> arguments)
+            : base(syntax)
+        {
+            Name = name;
+            Arguments = arguments;
+        }
+
+        public BoundExpression Name { get; }
+        public ImmutableArray<BoundExpression> 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<BoundStatement> body)
+            : base(syntax)
+        {
+            Condition = condition;
+            Body = body;
+        }
+
+        public BoundExpression Condition { get; }
+        public ImmutableArray<BoundStatement> Body { get; }
+        public override BoundNodeKind Kind => BoundNodeKind.ElseIfClause;
+    }
+
+    public class BoundElseClause : BoundNode
+    {
+        public BoundElseClause(SyntaxNode syntax, ImmutableArray<BoundStatement> body)
+            : base(syntax)
+        {
+            Body = body;
+        }
+
+        public ImmutableArray<BoundStatement> Body { get; }
+        public override BoundNodeKind Kind => BoundNodeKind.ElseClause;
+    }
+
+    public class BoundBinaryOperator
+    {
+        private static BoundBinaryOperator[] _operators =
+        {
+            new BoundBinaryOperator(TokenKind.EqualsToken, BoundBinaryOperatorKind.Equals),
+            new BoundBinaryOperator(TokenKind.PipePipeToken, BoundBinaryOperatorKind.PipePipe),
+            new BoundBinaryOperator(TokenKind.AmpersandAmpersandToken, BoundBinaryOperatorKind.AmpersandAmpersand),
+            new BoundBinaryOperator(TokenKind.PipeToken, BoundBinaryOperatorKind.Pipe),
+            new BoundBinaryOperator(TokenKind.AmpersandToken, BoundBinaryOperatorKind.Ampersand),
+            new BoundBinaryOperator(TokenKind.LessToken, BoundBinaryOperatorKind.Less),
+            new BoundBinaryOperator(TokenKind.LessOrEqualsToken, BoundBinaryOperatorKind.LessOrEquals),
+            new BoundBinaryOperator(TokenKind.GreaterToken, BoundBinaryOperatorKind.Greater),
+            new BoundBinaryOperator(TokenKind.GreaterOrEqualsToken, BoundBinaryOperatorKind.GreaterOrEquals),
+            new BoundBinaryOperator(TokenKind.EqualsEqualsToken, BoundBinaryOperatorKind.EqualsEquals),
+            new BoundBinaryOperator(TokenKind.TildeEqualsToken, BoundBinaryOperatorKind.TildeEquals),
+            new BoundBinaryOperator(TokenKind.ColonToken, BoundBinaryOperatorKind.Colon),
+            new BoundBinaryOperator(TokenKind.PlusToken, BoundBinaryOperatorKind.Plus),
+            new BoundBinaryOperator(TokenKind.MinusToken, BoundBinaryOperatorKind.Minus),
+            new BoundBinaryOperator(TokenKind.StarToken, BoundBinaryOperatorKind.Star),
+            new BoundBinaryOperator(TokenKind.DotStarToken, BoundBinaryOperatorKind.DotStar),
+            new BoundBinaryOperator(TokenKind.SlashToken, BoundBinaryOperatorKind.Slash),
+            new BoundBinaryOperator(TokenKind.DotSlashToken, BoundBinaryOperatorKind.DotSlash),
+            new BoundBinaryOperator(TokenKind.BackslashToken, BoundBinaryOperatorKind.Backslash),
+            new BoundBinaryOperator(TokenKind.DotBackslashToken, BoundBinaryOperatorKind.DotBackslash),
+            new BoundBinaryOperator(TokenKind.TildeToken, BoundBinaryOperatorKind.Tilde),
+            new BoundBinaryOperator(TokenKind.CaretToken, BoundBinaryOperatorKind.Caret),
+            new BoundBinaryOperator(TokenKind.DotCaretToken, BoundBinaryOperatorKind.DotCaret),
+        };
+
+        public BoundBinaryOperator(TokenKind syntaxKind, BoundBinaryOperatorKind kind)
+        {
+            SyntaxKind = syntaxKind;
+            Kind = kind;
+        }
+
+        public TokenKind SyntaxKind { get; }
+        public BoundBinaryOperatorKind Kind { get; }
+
+        internal static BoundBinaryOperator? GetOperator(TokenKind kind)
+        {
+            return _operators.FirstOrDefault(op => op.SyntaxKind == kind);
+        }
+    }
+}

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();
         }
     }

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<EvaluationScope> _scopeStack = new Stack<EvaluationScope>();
 
-        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<MObject>();
-            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();
         }

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<UnquotedStringLiteralSyntaxNode>();
+                var builder = new SyntaxListBuilder<UnquotedStringLiteralExpressionSyntaxNode>();
                 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,

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<UnquotedStringLiteralSyntaxNode> arguments)
+        public CommandExpressionSyntaxNode CommandExpressionSyntax(SyntaxToken commandName, SyntaxList<UnquotedStringLiteralExpressionSyntaxNode> 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<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword)
+        public ConcreteMethodDeclarationSyntaxNode ConcreteMethodDeclarationSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> 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)

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<UnquotedStringLiteralSyntaxNode> _arguments;
-        internal CommandExpressionSyntaxNode(SyntaxToken commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments): base(TokenKind.CommandExpression)
+        internal readonly SyntaxList<UnquotedStringLiteralExpressionSyntaxNode> _arguments;
+        internal CommandExpressionSyntaxNode(SyntaxToken commandName, SyntaxList<UnquotedStringLiteralExpressionSyntaxNode> arguments): base(TokenKind.CommandExpression)
         {
             Slots = 2;
             this.AdjustWidth(commandName);
@@ -1659,7 +1659,7 @@ namespace Parser.Internal
             _arguments = arguments;
         }
 
-        internal CommandExpressionSyntaxNode(SyntaxToken commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments, TokenDiagnostic[] diagnostics): base(TokenKind.CommandExpression, diagnostics)
+        internal CommandExpressionSyntaxNode(SyntaxToken commandName, SyntaxList<UnquotedStringLiteralExpressionSyntaxNode> 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<SyntaxToken> _commas;
         internal readonly SyntaxList _body;
         internal readonly EndKeywordSyntaxNode? _endKeyword;
-        internal MethodDefinitionSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.ConcreteMethodDeclaration)
+        internal ConcreteMethodDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> 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<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ConcreteMethodDeclaration, diagnostics)
+        internal ConcreteMethodDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> 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)

Parser/SyntaxDefinition.xml

@@ -115,16 +115,16 @@
     <Class Name="IdentifierNameExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IdentifierNameExpression">
         <Field Type="SyntaxToken" Name="name" />
     </Class>
-    <Class Name="NumberLiteralSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="NumberLiteralExpression">
+    <Class Name="NumberLiteralExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="NumberLiteralExpression">
         <Field Type="SyntaxToken" Name="number" />
     </Class>
-    <Class Name="StringLiteralSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="StringLiteralExpression">
+    <Class Name="StringLiteralExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="StringLiteralExpression">
         <Field Type="SyntaxToken" Name="stringToken" />
     </Class>
-    <Class Name="DoubleQuotedStringLiteralSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="DoubleQuotedStringLiteralExpression">
+    <Class Name="DoubleQuotedStringLiteralExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="DoubleQuotedStringLiteralExpression">
         <Field Type="SyntaxToken" Name="stringToken" />
     </Class>
-    <Class Name="UnquotedStringLiteralSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="UnquotedStringLiteralExpression">
+    <Class Name="UnquotedStringLiteralExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="UnquotedStringLiteralExpression">
         <Field Type="SyntaxToken" Name="stringToken" />
     </Class>
     <Class Name="ArrayLiteralExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="ArrayLiteralExpression">
@@ -154,25 +154,25 @@
         <Field Type="SyntaxList" Name="nodes" />
         <Field Type="SyntaxToken" Name="closingBracket" />
     </Class>
-    <Class Name="MemberAccessSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="MemberAccessExpression">
+    <Class Name="MemberAccessExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="MemberAccessExpression">
         <Field Type="SyntaxNode" Name="leftOperand" />
         <Field Type="SyntaxToken" Name="dot" />
         <Field Type="SyntaxNode" Name="rightOperand" />
     </Class>
-    <Class Name="UnaryPostixOperationExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="UnaryPostfixOperationExpression">
+    <Class Name="UnaryPostfixOperationExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="UnaryPostfixOperationExpression">
         <Field Type="ExpressionSyntaxNode" Name="operand" />
         <Field Type="SyntaxToken" Name="operation" />
     </Class>
-    <Class Name="IndirectMemberAccessSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IndirectMemberAccessExpression">
+    <Class Name="IndirectMemberAccessExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IndirectMemberAccessExpression">
         <Field Type="SyntaxToken" Name="openingBracket" />
         <Field Type="ExpressionSyntaxNode" Name="expression" />
         <Field Type="SyntaxToken" Name="closingBracket" />
     </Class>
     <Class Name="CommandExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CommandExpression">
         <Field Type="SyntaxToken" Name="commandName" />
-        <Field Type="SyntaxList&lt;UnquotedStringLiteralSyntaxNode&gt;" Name="arguments" />
+        <Field Type="SyntaxList&lt;UnquotedStringLiteralExpressionSyntaxNode&gt;" Name="arguments" />
     </Class>
-    <Class Name="BaseClassInvokationSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="ClassInvokationExpression">
+    <Class Name="ClassInvokationExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="ClassInvokationExpression">
         <Field Type="ExpressionSyntaxNode" Name="methodName" />
         <Field Type="SyntaxToken" Name="atSign" />
         <Field Type="ExpressionSyntaxNode" Name="baseClassNameAndArguments" />
@@ -190,7 +190,7 @@
         <Field Type="SyntaxList" Name="nodes" />
         <Field Type="SyntaxToken" Name="closingBracket" />
     </Class>
-    <Class Name="MethodDefinitionSyntaxNode" BaseClass="MethodDeclarationSyntaxNode" Kind="ConcreteMethodDeclaration">
+    <Class Name="ConcreteMethodDeclarationSyntaxNode" BaseClass="MethodDeclarationSyntaxNode" Kind="ConcreteMethodDeclaration">
         <Field Type="SyntaxToken" Name="functionKeyword" />
         <Field Type="FunctionOutputDescriptionSyntaxNode" Name="outputDescription" Nullable="true" />
         <Field Type="CompoundNameExpressionSyntaxNode" Name="name" />

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);
         }
     }
 

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);
         }

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)

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));
                 }

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);