diff --git a/ConsoleDemo/DumbWalker.cs b/ConsoleDemo/DumbWalker.cs
index 597e084..7914769 100644
--- a/ConsoleDemo/DumbWalker.cs
+++ b/ConsoleDemo/DumbWalker.cs
@@ -22,8 +22,8 @@ namespace ConsoleDemo
         {
             switch (lhs.Kind)
             {
-                case TokenKind.IdentifierName:
-                    var name = ((IdentifierNameSyntaxNode) lhs).Name.Text;
+                case TokenKind.IdentifierNameExpression:
+                    var name = ((IdentifierNameExpressionSyntaxNode) lhs).Name.Text;
                     Console.WriteLine($"Adding variable assignment for {name}");
                     _variableAssignments.Add(name, new Variable());
                     break;
@@ -66,8 +66,8 @@ namespace ConsoleDemo
         {
             switch (node.Kind)
             {
-                case TokenKind.IdentifierName:
-                    var name = (IdentifierNameSyntaxNode) node;
+                case TokenKind.IdentifierNameExpression:
+                    var name = (IdentifierNameExpressionSyntaxNode) node;
                     if (_context.FindFunction(name.Name.Text))
                     {
                         return true;
@@ -90,7 +90,7 @@ namespace ConsoleDemo
             Variable assignment;
             switch (node.Kind)
             {
-                case TokenKind.IdentifierName:
+                case TokenKind.IdentifierNameExpression:
                     assignment = _variableAssignments.Find(node.Text);
                     if (assignment != null || node.Text == "end")
                     {
@@ -98,12 +98,12 @@ namespace ConsoleDemo
                     }
 
                     break;
-                case TokenKind.FunctionCall:
+                case TokenKind.FunctionCallExpression:
                     var functionCall = (FunctionCallExpressionSyntaxNode)node;
                     return
                         (IsDefined(functionCall.FunctionName) && IsDefined(functionCall.Nodes)) ||
                         (IsDefinedFunctionName(functionCall.FunctionName) && IsDefined(functionCall.Nodes));
-                case TokenKind.CellArrayElementAccess:
+                case TokenKind.CellArrayElementAccessExpression:
                     var cellArrayElementAccess = (CellArrayElementAccessExpressionSyntaxNode) node;
                     return IsDefined(cellArrayElementAccess.Expression) && IsDefined(cellArrayElementAccess.Nodes);
                 case TokenKind.List:
@@ -113,7 +113,7 @@ namespace ConsoleDemo
                     return true;
                 case TokenKind.StringLiteralExpression:
                     return true;
-                case TokenKind.BinaryOperation:
+                case TokenKind.BinaryOperationExpression:
                     var binaryOperation = (BinaryOperationExpressionSyntaxNode) node;
                     return IsDefined(binaryOperation.Lhs) && IsDefined(binaryOperation.Rhs);
                 case TokenKind.UnaryPrefixOperationExpression:
@@ -139,7 +139,7 @@ namespace ConsoleDemo
                 {
                     var parameterAsNode = parameter.AsNode();
                     Console.WriteLine($"Parameter node: {parameterAsNode}");
-                    if (parameterAsNode.Kind == TokenKind.IdentifierName)
+                    if (parameterAsNode.Kind == TokenKind.IdentifierNameExpression)
                     {
                         Console.WriteLine($"Adding variable assignment for {parameterAsNode.Text}");
                         _variableAssignments.Add(parameterAsNode.Text, new Variable());
diff --git a/ConsoleDemo/PrettyPrinter.cs b/ConsoleDemo/PrettyPrinter.cs
index 1f2be12..0cbf492 100644
--- a/ConsoleDemo/PrettyPrinter.cs
+++ b/ConsoleDemo/PrettyPrinter.cs
@@ -274,7 +274,7 @@ namespace ProjectConsole
             OutputBracket(node.ClosingBrace);            
         }
 
-        public override void VisitIdentifierName(IdentifierNameSyntaxNode node)
+        public override void VisitIdentifierNameExpression(IdentifierNameExpressionSyntaxNode node)
         {
             OutputIdentifier(node.Name);
         }
@@ -410,7 +410,7 @@ namespace ProjectConsole
             OutputBracket(node.ClosingBrace);
         }
 
-        public override void VisitCompoundName(CompoundNameSyntaxNode node)
+        public override void VisitCompoundNameExpression(CompoundNameExpressionSyntaxNode node)
         {
             Visit(node.Nodes);
         }
@@ -479,14 +479,14 @@ namespace ProjectConsole
             OutputBracket(node.ClosingBracket);
         }
 
-        public override void VisitLambda(LambdaSyntaxNode node)
+        public override void VisitLambdaExpression(LambdaExpressionSyntaxNode node)
         {
             OutputOperator(node.AtSign);
             Visit(node.Input);
             Visit(node.Body);
         }
 
-        public override void VisitNamedFunctionHandle(NamedFunctionHandleSyntaxNode node)
+        public override void VisitNamedFunctionHandleExpression(NamedFunctionHandleExpressionSyntaxNode node)
         {
             OutputOperator(node.AtSign);
             Visit(node.FunctionName);
diff --git a/ConsoleDemo/UsageGathering.cs b/ConsoleDemo/UsageGathering.cs
index 53ea181..6665443 100644
--- a/ConsoleDemo/UsageGathering.cs
+++ b/ConsoleDemo/UsageGathering.cs
@@ -49,8 +49,8 @@ namespace ConsoleDemo
         {
             switch (lhs.Kind)
             {
-                case TokenKind.IdentifierName:
-                    var name = ((IdentifierNameSyntaxNode)lhs).Name.Text;
+                case TokenKind.IdentifierNameExpression:
+                    var name = ((IdentifierNameExpressionSyntaxNode)lhs).Name.Text;
                     Console.WriteLine($"Adding variable assignment for {name}");
                     _variableAssignments.Add(name, new Variable());
                     break;
@@ -100,7 +100,7 @@ namespace ConsoleDemo
                 {
                     var parameterAsNode = parameter.AsNode();
                     Console.WriteLine($"Parameter node: {parameterAsNode}");
-                    if (parameterAsNode.Kind == TokenKind.IdentifierName)
+                    if (parameterAsNode.Kind == TokenKind.IdentifierNameExpression)
                     {
                         Console.WriteLine($"Adding variable assignment for {parameterAsNode.Text}");
                         _variableAssignments.Add(parameterAsNode.Text, new Variable());
@@ -131,7 +131,7 @@ namespace ConsoleDemo
                 {
                     var parameterAsNode = parameter.AsNode();
                     Console.WriteLine($"Parameter node: {parameterAsNode}");
-                    if (parameterAsNode.Kind == TokenKind.IdentifierName)
+                    if (parameterAsNode.Kind == TokenKind.IdentifierNameExpression)
                     {
                         Console.WriteLine($"Adding variable assignment for {parameterAsNode.Text}");
                         _variableAssignments.Add(parameterAsNode.Text, new Variable());
diff --git a/MApplication/ColoringVisitor.cs b/MApplication/ColoringVisitor.cs
index 16bce5a..28aa2f6 100644
--- a/MApplication/ColoringVisitor.cs
+++ b/MApplication/ColoringVisitor.cs
@@ -221,7 +221,7 @@ namespace MApplication
             AddToken(node.ClosingBrace, _scheme.Bracket);
         }
 
-        public override void VisitIdentifierName(IdentifierNameSyntaxNode node)
+        public override void VisitIdentifierNameExpression(IdentifierNameExpressionSyntaxNode node)
         {
             AddToken(node.Name, _scheme.Identifier);
         }
@@ -357,7 +357,7 @@ namespace MApplication
             AddToken(node.ClosingBrace, _scheme.Bracket);
         }
 
-        public override void VisitCompoundName(CompoundNameSyntaxNode node)
+        public override void VisitCompoundNameExpression(CompoundNameExpressionSyntaxNode node)
         {
             Visit(node.Nodes);
         }
@@ -426,14 +426,14 @@ namespace MApplication
             AddToken(node.ClosingBracket, _scheme.Bracket);
         }
 
-        public override void VisitLambda(LambdaSyntaxNode node)
+        public override void VisitLambdaExpression(LambdaExpressionSyntaxNode node)
         {
             AddToken(node.AtSign, _scheme.Operator);
             Visit(node.Input);
             Visit(node.Body);
         }
 
-        public override void VisitNamedFunctionHandle(NamedFunctionHandleSyntaxNode node)
+        public override void VisitNamedFunctionHandleExpression(NamedFunctionHandleExpressionSyntaxNode node)
         {
             AddToken(node.AtSign, _scheme.Operator);
             Visit(node.FunctionName);
diff --git a/Parser/Evaluator.cs b/Parser/Evaluator.cs
index ed0bf15..15ac7f5 100644
--- a/Parser/Evaluator.cs
+++ b/Parser/Evaluator.cs
@@ -43,28 +43,28 @@ namespace Parser
         {
             return statement.Kind switch
             {
-                TokenKind.ExpressionStatement =>
-                    EvaluateExpressionStatement((ExpressionStatementSyntaxNode)statement),
-                TokenKind.MethodDefinition =>
-                    EvaluateMethodDefinition((MethodDefinitionSyntaxNode)statement),
                 TokenKind.AbstractMethodDeclaration =>
                     EvaluateAbstractMethodDeclaration((AbstractMethodDeclarationSyntaxNode)statement),
-                TokenKind.FunctionDeclaration =>
-                    EvaluateFunctionDeclaration((FunctionDeclarationSyntaxNode)statement),
-                TokenKind.SwitchStatement =>
-                    EvaluateSwitchStatement((SwitchStatementSyntaxNode)statement),
-                TokenKind.WhileStatement =>
-                    EvaluateWhileStatement((WhileStatementSyntaxNode)statement),
-                TokenKind.IfStatement =>
-                    EvaluateIfStatement((IfStatementSyntaxNode)statement),
-                TokenKind.ForStatement =>
-                    EvaluateForStatement((ForStatementSyntaxNode)statement),
-                TokenKind.TryCatchStatement =>
-                    EvaluateTryCatchStatement((TryCatchStatementSyntaxNode)statement),
-                TokenKind.EmptyStatement =>
-                    EvaluateEmptyStatement((EmptyStatementSyntaxNode)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}'."),
             };
         }
@@ -128,52 +128,59 @@ namespace Parser
         {
             return expression.Kind switch
             {
-                TokenKind.Lambda =>
-                    EvaluateLambda((LambdaSyntaxNode)expression),
-                TokenKind.AssignmentExpression =>
-                    EvaluateAssignmentExpression((AssignmentExpressionSyntaxNode)expression),
-                TokenKind.EmptyExpression =>
-                    EvaluateEmptyExpression((EmptyExpressionSyntaxNode)expression),
-                TokenKind.UnaryPrefixOperationExpression =>
-                    EvaluateUnaryPrefixOperationExpression((UnaryPrefixOperationExpressionSyntaxNode)expression),
-                TokenKind.CompoundName =>
-                    EvaluateCompoundName((CompoundNameSyntaxNode)expression),
-                TokenKind.BinaryOperation =>
-                    EvaluateBinaryOperation((BinaryOperationExpressionSyntaxNode)expression),
-                TokenKind.IdentifierName =>
-                    EvaluateIdentifierName((IdentifierNameSyntaxNode)expression),
-                TokenKind.NumberLiteralExpression =>
-                    EvaluateNumberLiteralExpression((NumberLiteralSyntaxNode)expression),
-                TokenKind.StringLiteralExpression =>
-                    EvaluateStringLiteralExpression((StringLiteralSyntaxNode)expression),
-                TokenKind.DoubleQuotedStringLiteralExpression =>
-                    EvaluateDoubleQuotedStringLiteralExpression((DoubleQuotedStringLiteralSyntaxNode)expression),
-                TokenKind.UnquotedStringLiteralExpression =>
-                    EvaluateUnquotedStringLiteralExpression((UnquotedStringLiteralSyntaxNode)expression),
                 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.ParenthesizedExpression =>
-                    EvaluateNamedFunctionHandle((NamedFunctionHandleSyntaxNode)expression),
-                TokenKind.CellArrayElementAccess =>
-                    EvaluateCellArrayElementAccess((CellArrayElementAccessExpressionSyntaxNode)expression),
-                TokenKind.FunctionCall =>
+                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.MemberAccess =>
+                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.IndirectMemberAccess =>
-                    EvaluateIndirectMemberAccess((IndirectMemberAccessSyntaxNode)expression),
-                TokenKind.Command =>
-                    EvaluateCommand((CommandExpressionSyntaxNode)expression),
-                TokenKind.ClassInvokation =>
-                    EvaluateClassInvokation((BaseClassInvokationSyntaxNode)expression),
+                TokenKind.UnquotedStringLiteralExpression =>
+                    EvaluateUnquotedStringLiteralExpression((UnquotedStringLiteralSyntaxNode)expression),
                 _ => throw new NotImplementedException($"Invalid expression kind '{expression.Kind}'."),
             };
         }
 
+        private MObject? EvaluateParenthesizedExpression(ParenthesizedExpressionSyntaxNode expression)
+        {
+            throw new NotImplementedException();
+        }
+
         private MObject? EvaluateClassInvokation(BaseClassInvokationSyntaxNode expression)
         {
             throw new NotImplementedException();
@@ -239,7 +246,7 @@ namespace Parser
             throw new NotImplementedException();
         }
 
-        private MObject? EvaluateIdentifierName(IdentifierNameSyntaxNode expression)
+        private MObject? EvaluateIdentifierNameExpression(IdentifierNameExpressionSyntaxNode expression)
         {
             throw new NotImplementedException();
         }
@@ -249,7 +256,7 @@ namespace Parser
             throw new NotImplementedException();
         }
 
-        private MObject? EvaluateCompoundName(CompoundNameSyntaxNode expression)
+        private MObject? EvaluateCompoundName(CompoundNameExpressionSyntaxNode expression)
         {
             throw new NotImplementedException();
         }
@@ -269,12 +276,12 @@ namespace Parser
             throw new NotImplementedException();
         }
 
-        private MObject? EvaluateLambda(LambdaSyntaxNode expression)
+        private MObject? EvaluateLambdaExpression(LambdaExpressionSyntaxNode expression)
         {
             throw new NotImplementedException();
         }
 
-        private MObject? EvaluateNamedFunctionHandle(NamedFunctionHandleSyntaxNode expression)
+        private MObject? EvaluateNamedFunctionHandleExpression(NamedFunctionHandleExpressionSyntaxNode expression)
         {
             throw new NotImplementedException();
         }
diff --git a/Parser/Internal/MParserGreen.cs b/Parser/Internal/MParserGreen.cs
index 1591bb2..bc87a9b 100644
--- a/Parser/Internal/MParserGreen.cs
+++ b/Parser/Internal/MParserGreen.cs
@@ -113,7 +113,7 @@ namespace Parser.Internal
                 }
 
                 firstToken = false;
-                outputs.Add(Factory.IdentifierNameSyntax(EatToken(TokenKind.IdentifierToken)));
+                outputs.Add(Factory.IdentifierNameExpressionSyntax(EatToken(TokenKind.IdentifierToken)));
             }
 
             return outputs.ToList();
@@ -141,7 +141,7 @@ namespace Parser.Internal
                 if (PeekToken(1).Kind == TokenKind.EqualsToken)
                 {
                     var identifierToken = EatIdentifier();
-                    builder.Add(Factory.IdentifierNameSyntax(identifierToken));
+                    builder.Add(Factory.IdentifierNameExpressionSyntax(identifierToken));
                     assignmentSign = EatToken(TokenKind.EqualsToken);
                 }
                 else
@@ -180,7 +180,7 @@ namespace Parser.Internal
                 else
                 {
                     var identifierToken = EatToken(TokenKind.IdentifierToken);
-                    builder.Add(Factory.IdentifierNameSyntax(identifierToken));
+                    builder.Add(Factory.IdentifierNameExpressionSyntax(identifierToken));
                 }
             }
 
@@ -329,7 +329,7 @@ namespace Parser.Internal
                     break;
                 default:
                     var id = EatToken(TokenKind.IdentifierToken);
-                    expression = Factory.IdentifierNameSyntax(id);
+                    expression = Factory.IdentifierNameExpressionSyntax(id);
                     break;
             }
 
@@ -377,7 +377,7 @@ namespace Parser.Internal
                             closingBracket);
                         break;
                     case TokenKind.DotToken: // member access
-                        if (expression is IdentifierNameSyntaxNode
+                        if (expression is IdentifierNameExpressionSyntaxNode
                             || expression is MemberAccessSyntaxNode
                             || expression is FunctionCallExpressionSyntaxNode
                             || expression is CellArrayElementAccessExpressionSyntaxNode)
@@ -414,7 +414,7 @@ namespace Parser.Internal
 
         private CommandExpressionSyntaxNode ParseCommandExpression(ExpressionSyntaxNode expression)
         {
-            if (expression is IdentifierNameSyntaxNode idNameNode)
+            if (expression is IdentifierNameExpressionSyntaxNode idNameNode)
             {
                 var builder = new SyntaxListBuilder<UnquotedStringLiteralSyntaxNode>();
                 while (CurrentToken.Kind == TokenKind.UnquotedStringLiteralToken)
@@ -434,7 +434,7 @@ namespace Parser.Internal
 
         private BaseClassInvokationSyntaxNode ParseBaseClassInvokation(ExpressionSyntaxNode expression)
         {
-            if (expression is IdentifierNameSyntaxNode methodName
+            if (expression is IdentifierNameExpressionSyntaxNode methodName
                 && !expression.TrailingTrivia.Any())
             {
                 var atToken = EatToken();
@@ -463,7 +463,7 @@ namespace Parser.Internal
         {
             if (CurrentToken.Kind == TokenKind.IdentifierToken)
             {
-                return Factory.IdentifierNameSyntax(EatToken());
+                return Factory.IdentifierNameExpressionSyntax(EatToken());
             }
             if (CurrentToken.Kind == TokenKind.OpenParenthesisToken)
             {
@@ -523,7 +523,7 @@ namespace Parser.Internal
                 closeParen);
         }
 
-        private CompoundNameSyntaxNode ParseCompoundName()
+        private CompoundNameExpressionSyntaxNode ParseCompoundName()
         {
             var lastToken = EatToken(TokenKind.IdentifierToken);
             var firstName = lastToken;
@@ -538,16 +538,16 @@ namespace Parser.Internal
                 builder.Add(lastToken);
             }
 
-            return Factory.CompoundNameSyntax(builder.ToList());
+            return Factory.CompoundNameExpressionSyntax(builder.ToList());
         }
 
-        private FunctionHandleSyntaxNode ParseFunctionHandle()
+        private FunctionHandleExpressionSyntaxNode ParseFunctionHandle()
         {
             var atSign = EatToken();
             if (CurrentToken.Kind == TokenKind.IdentifierToken)
             {
                 var compoundName = ParseCompoundName();
-                return Factory.NamedFunctionHandleSyntax(
+                return Factory.NamedFunctionHandleExpressionSyntax(
                     atSign,
                     compoundName);
             }
@@ -563,7 +563,7 @@ namespace Parser.Internal
                 {
                     throw new Exception($"Lambda expression body cannot be empty.");
                 }
-                return Factory.LambdaSyntax(atSign, inputs, body);
+                return Factory.LambdaExpressionSyntax(atSign, inputs, body);
             }
             throw new ParsingException($"Unexpected token {CurrentToken} while parsing function handle at {CurrentPosition}.");
         }
@@ -866,7 +866,7 @@ namespace Parser.Internal
 
         private AttributeSyntaxNode ParseAttribute()
         {
-            var name = Factory.IdentifierNameSyntax(EatToken(TokenKind.IdentifierToken));
+            var name = Factory.IdentifierNameExpressionSyntax(EatToken(TokenKind.IdentifierToken));
             var assignment = ParseAttributeAssignment();
             return Factory.AttributeSyntax(name, assignment);
         }
@@ -1023,7 +1023,7 @@ namespace Parser.Internal
 
         private EnumerationItemSyntaxNode ParseEnumerationItem()
         {
-            var name = Factory.IdentifierNameSyntax(EatToken());
+            var name = Factory.IdentifierNameExpressionSyntax(EatToken());
             var values = ParseEnumerationValue();
             var commas = ParseOptionalCommas();
             return Factory.EnumerationItemSyntax(name, values, commas);
@@ -1104,7 +1104,7 @@ namespace Parser.Internal
             {
                 attributes = ParseAttributesList();
             }
-            var className = Factory.IdentifierNameSyntax(EatToken(TokenKind.IdentifierToken));
+            var className = Factory.IdentifierNameExpressionSyntax(EatToken(TokenKind.IdentifierToken));
             BaseClassListSyntaxNode? baseClassList = null;
             if (CurrentToken.Kind == TokenKind.LessToken)
             {
diff --git a/Parser/Internal/SyntaxFactory.Generated.cs b/Parser/Internal/SyntaxFactory.Generated.cs
index fe84e55..389f615 100644
--- a/Parser/Internal/SyntaxFactory.Generated.cs
+++ b/Parser/Internal/SyntaxFactory.Generated.cs
@@ -93,19 +93,19 @@ namespace Parser.Internal
             return new UnaryPrefixOperationExpressionSyntaxNode(operation, operand);
         }
 
-        public CompoundNameSyntaxNode CompoundNameSyntax(SyntaxList nodes)
+        public CompoundNameExpressionSyntaxNode CompoundNameExpressionSyntax(SyntaxList nodes)
         {
-            return new CompoundNameSyntaxNode(nodes);
+            return new CompoundNameExpressionSyntaxNode(nodes);
         }
 
-        public NamedFunctionHandleSyntaxNode NamedFunctionHandleSyntax(SyntaxToken atSign, CompoundNameSyntaxNode functionName)
+        public NamedFunctionHandleExpressionSyntaxNode NamedFunctionHandleExpressionSyntax(SyntaxToken atSign, CompoundNameExpressionSyntaxNode functionName)
         {
-            return new NamedFunctionHandleSyntaxNode(atSign, functionName);
+            return new NamedFunctionHandleExpressionSyntaxNode(atSign, functionName);
         }
 
-        public LambdaSyntaxNode LambdaSyntax(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body)
+        public LambdaExpressionSyntaxNode LambdaExpressionSyntax(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body)
         {
-            return new LambdaSyntaxNode(atSign, input, body);
+            return new LambdaExpressionSyntaxNode(atSign, input, body);
         }
 
         public BinaryOperationExpressionSyntaxNode BinaryOperationExpressionSyntax(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs)
@@ -113,9 +113,9 @@ namespace Parser.Internal
             return new BinaryOperationExpressionSyntaxNode(lhs, operation, rhs);
         }
 
-        public IdentifierNameSyntaxNode IdentifierNameSyntax(SyntaxToken name)
+        public IdentifierNameExpressionSyntaxNode IdentifierNameExpressionSyntax(SyntaxToken name)
         {
-            return new IdentifierNameSyntaxNode(name);
+            return new IdentifierNameExpressionSyntaxNode(name);
         }
 
         public NumberLiteralSyntaxNode NumberLiteralSyntax(SyntaxToken number)
@@ -178,7 +178,7 @@ namespace Parser.Internal
             return new IndirectMemberAccessSyntaxNode(openingBracket, expression, closingBracket);
         }
 
-        public CommandExpressionSyntaxNode CommandExpressionSyntax(IdentifierNameSyntaxNode commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments)
+        public CommandExpressionSyntaxNode CommandExpressionSyntax(IdentifierNameExpressionSyntaxNode commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments)
         {
             return new CommandExpressionSyntaxNode(commandName, arguments);
         }
@@ -193,7 +193,7 @@ namespace Parser.Internal
             return new AttributeAssignmentSyntaxNode(assignmentSign, value);
         }
 
-        public AttributeSyntaxNode AttributeSyntax(IdentifierNameSyntaxNode name, AttributeAssignmentSyntaxNode? assignment)
+        public AttributeSyntaxNode AttributeSyntax(IdentifierNameExpressionSyntaxNode name, AttributeAssignmentSyntaxNode? assignment)
         {
             return new AttributeSyntaxNode(name, assignment);
         }
@@ -203,12 +203,12 @@ namespace Parser.Internal
             return new AttributeListSyntaxNode(openingBracket, nodes, closingBracket);
         }
 
-        public MethodDefinitionSyntaxNode MethodDefinitionSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword)
+        public MethodDefinitionSyntaxNode MethodDefinitionSyntax(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);
         }
 
-        public AbstractMethodDeclarationSyntaxNode AbstractMethodDeclarationSyntax(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription)
+        public AbstractMethodDeclarationSyntaxNode AbstractMethodDeclarationSyntax(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription)
         {
             return new AbstractMethodDeclarationSyntaxNode(outputDescription, name, inputDescription);
         }
@@ -228,7 +228,7 @@ namespace Parser.Internal
             return new BaseClassListSyntaxNode(lessSign, baseClasses);
         }
 
-        public ClassDeclarationSyntaxNode ClassDeclarationSyntax(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword)
+        public ClassDeclarationSyntaxNode ClassDeclarationSyntax(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameExpressionSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword)
         {
             return new ClassDeclarationSyntaxNode(classdefKeyword, attributes, className, baseClassList, nodes, endKeyword);
         }
@@ -238,7 +238,7 @@ namespace Parser.Internal
             return new EnumerationItemValueSyntaxNode(openingBracket, values, closingBracket);
         }
 
-        public EnumerationItemSyntaxNode EnumerationItemSyntax(IdentifierNameSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList<SyntaxToken> commas)
+        public EnumerationItemSyntaxNode EnumerationItemSyntax(IdentifierNameExpressionSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList<SyntaxToken> commas)
         {
             return new EnumerationItemSyntaxNode(name, values, commas);
         }
diff --git a/Parser/Internal/SyntaxNode.Generated.cs b/Parser/Internal/SyntaxNode.Generated.cs
index 32742dd..c5cf33c 100644
--- a/Parser/Internal/SyntaxNode.Generated.cs
+++ b/Parser/Internal/SyntaxNode.Generated.cs
@@ -890,17 +890,17 @@ namespace Parser.Internal
         }
     }
 
-    internal class CompoundNameSyntaxNode : ExpressionSyntaxNode
+    internal class CompoundNameExpressionSyntaxNode : ExpressionSyntaxNode
     {
         internal readonly SyntaxList _nodes;
-        internal CompoundNameSyntaxNode(SyntaxList nodes): base(TokenKind.CompoundName)
+        internal CompoundNameExpressionSyntaxNode(SyntaxList nodes): base(TokenKind.CompoundNameExpression)
         {
             Slots = 1;
             this.AdjustWidth(nodes);
             _nodes = nodes;
         }
 
-        internal CompoundNameSyntaxNode(SyntaxList nodes, TokenDiagnostic[] diagnostics): base(TokenKind.CompoundName, diagnostics)
+        internal CompoundNameExpressionSyntaxNode(SyntaxList nodes, TokenDiagnostic[] diagnostics): base(TokenKind.CompoundNameExpression, diagnostics)
         {
             Slots = 1;
             this.AdjustWidth(nodes);
@@ -909,12 +909,12 @@ namespace Parser.Internal
 
         internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position)
         {
-            return new Parser.CompoundNameSyntaxNode(parent, this, position);
+            return new Parser.CompoundNameExpressionSyntaxNode(parent, this, position);
         }
 
         public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics)
         {
-            return new CompoundNameSyntaxNode(_nodes, diagnostics);
+            return new CompoundNameExpressionSyntaxNode(_nodes, diagnostics);
         }
 
         public override GreenNode? GetSlot(int i)
@@ -928,11 +928,11 @@ namespace Parser.Internal
         }
     }
 
-    internal class NamedFunctionHandleSyntaxNode : FunctionHandleSyntaxNode
+    internal class NamedFunctionHandleExpressionSyntaxNode : FunctionHandleExpressionSyntaxNode
     {
         internal readonly SyntaxToken _atSign;
-        internal readonly CompoundNameSyntaxNode _functionName;
-        internal NamedFunctionHandleSyntaxNode(SyntaxToken atSign, CompoundNameSyntaxNode functionName): base(TokenKind.NamedFunctionHandle)
+        internal readonly CompoundNameExpressionSyntaxNode _functionName;
+        internal NamedFunctionHandleExpressionSyntaxNode(SyntaxToken atSign, CompoundNameExpressionSyntaxNode functionName): base(TokenKind.NamedFunctionHandleExpression)
         {
             Slots = 2;
             this.AdjustWidth(atSign);
@@ -941,7 +941,7 @@ namespace Parser.Internal
             _functionName = functionName;
         }
 
-        internal NamedFunctionHandleSyntaxNode(SyntaxToken atSign, CompoundNameSyntaxNode functionName, TokenDiagnostic[] diagnostics): base(TokenKind.NamedFunctionHandle, diagnostics)
+        internal NamedFunctionHandleExpressionSyntaxNode(SyntaxToken atSign, CompoundNameExpressionSyntaxNode functionName, TokenDiagnostic[] diagnostics): base(TokenKind.NamedFunctionHandleExpression, diagnostics)
         {
             Slots = 2;
             this.AdjustWidth(atSign);
@@ -952,12 +952,12 @@ namespace Parser.Internal
 
         internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position)
         {
-            return new Parser.NamedFunctionHandleSyntaxNode(parent, this, position);
+            return new Parser.NamedFunctionHandleExpressionSyntaxNode(parent, this, position);
         }
 
         public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics)
         {
-            return new NamedFunctionHandleSyntaxNode(_atSign, _functionName, diagnostics);
+            return new NamedFunctionHandleExpressionSyntaxNode(_atSign, _functionName, diagnostics);
         }
 
         public override GreenNode? GetSlot(int i)
@@ -971,12 +971,12 @@ namespace Parser.Internal
         }
     }
 
-    internal class LambdaSyntaxNode : FunctionHandleSyntaxNode
+    internal class LambdaExpressionSyntaxNode : FunctionHandleExpressionSyntaxNode
     {
         internal readonly SyntaxToken _atSign;
         internal readonly FunctionInputDescriptionSyntaxNode _input;
         internal readonly ExpressionSyntaxNode _body;
-        internal LambdaSyntaxNode(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body): base(TokenKind.Lambda)
+        internal LambdaExpressionSyntaxNode(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body): base(TokenKind.LambdaExpression)
         {
             Slots = 3;
             this.AdjustWidth(atSign);
@@ -987,7 +987,7 @@ namespace Parser.Internal
             _body = body;
         }
 
-        internal LambdaSyntaxNode(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.Lambda, diagnostics)
+        internal LambdaExpressionSyntaxNode(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.LambdaExpression, diagnostics)
         {
             Slots = 3;
             this.AdjustWidth(atSign);
@@ -1000,12 +1000,12 @@ namespace Parser.Internal
 
         internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position)
         {
-            return new Parser.LambdaSyntaxNode(parent, this, position);
+            return new Parser.LambdaExpressionSyntaxNode(parent, this, position);
         }
 
         public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics)
         {
-            return new LambdaSyntaxNode(_atSign, _input, _body, diagnostics);
+            return new LambdaExpressionSyntaxNode(_atSign, _input, _body, diagnostics);
         }
 
         public override GreenNode? GetSlot(int i)
@@ -1024,7 +1024,7 @@ namespace Parser.Internal
         internal readonly ExpressionSyntaxNode _lhs;
         internal readonly SyntaxToken _operation;
         internal readonly ExpressionSyntaxNode _rhs;
-        internal BinaryOperationExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs): base(TokenKind.BinaryOperation)
+        internal BinaryOperationExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs): base(TokenKind.BinaryOperationExpression)
         {
             Slots = 3;
             this.AdjustWidth(lhs);
@@ -1035,7 +1035,7 @@ namespace Parser.Internal
             _rhs = rhs;
         }
 
-        internal BinaryOperationExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs, TokenDiagnostic[] diagnostics): base(TokenKind.BinaryOperation, diagnostics)
+        internal BinaryOperationExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs, TokenDiagnostic[] diagnostics): base(TokenKind.BinaryOperationExpression, diagnostics)
         {
             Slots = 3;
             this.AdjustWidth(lhs);
@@ -1067,17 +1067,17 @@ namespace Parser.Internal
         }
     }
 
-    internal class IdentifierNameSyntaxNode : ExpressionSyntaxNode
+    internal class IdentifierNameExpressionSyntaxNode : ExpressionSyntaxNode
     {
         internal readonly SyntaxToken _name;
-        internal IdentifierNameSyntaxNode(SyntaxToken name): base(TokenKind.IdentifierName)
+        internal IdentifierNameExpressionSyntaxNode(SyntaxToken name): base(TokenKind.IdentifierNameExpression)
         {
             Slots = 1;
             this.AdjustWidth(name);
             _name = name;
         }
 
-        internal IdentifierNameSyntaxNode(SyntaxToken name, TokenDiagnostic[] diagnostics): base(TokenKind.IdentifierName, diagnostics)
+        internal IdentifierNameExpressionSyntaxNode(SyntaxToken name, TokenDiagnostic[] diagnostics): base(TokenKind.IdentifierNameExpression, diagnostics)
         {
             Slots = 1;
             this.AdjustWidth(name);
@@ -1086,12 +1086,12 @@ namespace Parser.Internal
 
         internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position)
         {
-            return new Parser.IdentifierNameSyntaxNode(parent, this, position);
+            return new Parser.IdentifierNameExpressionSyntaxNode(parent, this, position);
         }
 
         public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics)
         {
-            return new IdentifierNameSyntaxNode(_name, diagnostics);
+            return new IdentifierNameExpressionSyntaxNode(_name, diagnostics);
         }
 
         public override GreenNode? GetSlot(int i)
@@ -1407,7 +1407,7 @@ namespace Parser.Internal
         internal readonly SyntaxToken _openingBrace;
         internal readonly SyntaxList _nodes;
         internal readonly SyntaxToken _closingBrace;
-        internal CellArrayElementAccessExpressionSyntaxNode(ExpressionSyntaxNode expression, SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace): base(TokenKind.CellArrayElementAccess)
+        internal CellArrayElementAccessExpressionSyntaxNode(ExpressionSyntaxNode expression, SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace): base(TokenKind.CellArrayElementAccessExpression)
         {
             Slots = 4;
             this.AdjustWidth(expression);
@@ -1420,7 +1420,7 @@ namespace Parser.Internal
             _closingBrace = closingBrace;
         }
 
-        internal CellArrayElementAccessExpressionSyntaxNode(ExpressionSyntaxNode expression, SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace, TokenDiagnostic[] diagnostics): base(TokenKind.CellArrayElementAccess, diagnostics)
+        internal CellArrayElementAccessExpressionSyntaxNode(ExpressionSyntaxNode expression, SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace, TokenDiagnostic[] diagnostics): base(TokenKind.CellArrayElementAccessExpression, diagnostics)
         {
             Slots = 4;
             this.AdjustWidth(expression);
@@ -1460,7 +1460,7 @@ namespace Parser.Internal
         internal readonly SyntaxToken _openingBracket;
         internal readonly SyntaxList _nodes;
         internal readonly SyntaxToken _closingBracket;
-        internal FunctionCallExpressionSyntaxNode(ExpressionSyntaxNode functionName, SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket): base(TokenKind.FunctionCall)
+        internal FunctionCallExpressionSyntaxNode(ExpressionSyntaxNode functionName, SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket): base(TokenKind.FunctionCallExpression)
         {
             Slots = 4;
             this.AdjustWidth(functionName);
@@ -1473,7 +1473,7 @@ namespace Parser.Internal
             _closingBracket = closingBracket;
         }
 
-        internal FunctionCallExpressionSyntaxNode(ExpressionSyntaxNode functionName, SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.FunctionCall, diagnostics)
+        internal FunctionCallExpressionSyntaxNode(ExpressionSyntaxNode functionName, SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.FunctionCallExpression, diagnostics)
         {
             Slots = 4;
             this.AdjustWidth(functionName);
@@ -1512,7 +1512,7 @@ namespace Parser.Internal
         internal readonly SyntaxNode _leftOperand;
         internal readonly SyntaxToken _dot;
         internal readonly SyntaxNode _rightOperand;
-        internal MemberAccessSyntaxNode(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand): base(TokenKind.MemberAccess)
+        internal MemberAccessSyntaxNode(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.MemberAccess, diagnostics)
+        internal MemberAccessSyntaxNode(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand, TokenDiagnostic[] diagnostics): base(TokenKind.MemberAccessExpression, diagnostics)
         {
             Slots = 3;
             this.AdjustWidth(leftOperand);
@@ -1603,7 +1603,7 @@ namespace Parser.Internal
         internal readonly SyntaxToken _openingBracket;
         internal readonly ExpressionSyntaxNode _expression;
         internal readonly SyntaxToken _closingBracket;
-        internal IndirectMemberAccessSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket): base(TokenKind.IndirectMemberAccess)
+        internal IndirectMemberAccessSyntaxNode(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.IndirectMemberAccess, diagnostics)
+        internal IndirectMemberAccessSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.IndirectMemberAccessExpression, diagnostics)
         {
             Slots = 3;
             this.AdjustWidth(openingBracket);
@@ -1648,9 +1648,9 @@ namespace Parser.Internal
 
     internal class CommandExpressionSyntaxNode : ExpressionSyntaxNode
     {
-        internal readonly IdentifierNameSyntaxNode _commandName;
+        internal readonly IdentifierNameExpressionSyntaxNode _commandName;
         internal readonly SyntaxList<UnquotedStringLiteralSyntaxNode> _arguments;
-        internal CommandExpressionSyntaxNode(IdentifierNameSyntaxNode commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments): base(TokenKind.Command)
+        internal CommandExpressionSyntaxNode(IdentifierNameExpressionSyntaxNode commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments): base(TokenKind.CommandExpression)
         {
             Slots = 2;
             this.AdjustWidth(commandName);
@@ -1659,7 +1659,7 @@ namespace Parser.Internal
             _arguments = arguments;
         }
 
-        internal CommandExpressionSyntaxNode(IdentifierNameSyntaxNode commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments, TokenDiagnostic[] diagnostics): base(TokenKind.Command, diagnostics)
+        internal CommandExpressionSyntaxNode(IdentifierNameExpressionSyntaxNode commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments, TokenDiagnostic[] diagnostics): base(TokenKind.CommandExpression, diagnostics)
         {
             Slots = 2;
             this.AdjustWidth(commandName);
@@ -1694,7 +1694,7 @@ namespace Parser.Internal
         internal readonly ExpressionSyntaxNode _methodName;
         internal readonly SyntaxToken _atSign;
         internal readonly ExpressionSyntaxNode _baseClassNameAndArguments;
-        internal BaseClassInvokationSyntaxNode(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments): base(TokenKind.ClassInvokation)
+        internal BaseClassInvokationSyntaxNode(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.ClassInvokation, diagnostics)
+        internal BaseClassInvokationSyntaxNode(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments, TokenDiagnostic[] diagnostics): base(TokenKind.ClassInvokationExpression, diagnostics)
         {
             Slots = 3;
             this.AdjustWidth(methodName);
@@ -1782,9 +1782,9 @@ namespace Parser.Internal
 
     internal class AttributeSyntaxNode : SyntaxNode
     {
-        internal readonly IdentifierNameSyntaxNode _name;
+        internal readonly IdentifierNameExpressionSyntaxNode _name;
         internal readonly AttributeAssignmentSyntaxNode? _assignment;
-        internal AttributeSyntaxNode(IdentifierNameSyntaxNode name, AttributeAssignmentSyntaxNode? assignment): base(TokenKind.Attribute)
+        internal AttributeSyntaxNode(IdentifierNameExpressionSyntaxNode name, AttributeAssignmentSyntaxNode? assignment): base(TokenKind.Attribute)
         {
             Slots = 2;
             this.AdjustWidth(name);
@@ -1793,7 +1793,7 @@ namespace Parser.Internal
             _assignment = assignment;
         }
 
-        internal AttributeSyntaxNode(IdentifierNameSyntaxNode name, AttributeAssignmentSyntaxNode? assignment, TokenDiagnostic[] diagnostics): base(TokenKind.Attribute, diagnostics)
+        internal AttributeSyntaxNode(IdentifierNameExpressionSyntaxNode name, AttributeAssignmentSyntaxNode? assignment, TokenDiagnostic[] diagnostics): base(TokenKind.Attribute, diagnostics)
         {
             Slots = 2;
             this.AdjustWidth(name);
@@ -1875,12 +1875,12 @@ namespace Parser.Internal
     {
         internal readonly SyntaxToken _functionKeyword;
         internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription;
-        internal readonly CompoundNameSyntaxNode _name;
+        internal readonly CompoundNameExpressionSyntaxNode _name;
         internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription;
         internal readonly SyntaxList<SyntaxToken> _commas;
         internal readonly SyntaxList _body;
         internal readonly EndKeywordSyntaxNode? _endKeyword;
-        internal MethodDefinitionSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.MethodDefinition)
+        internal MethodDefinitionSyntaxNode(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, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.MethodDefinition, diagnostics)
+        internal MethodDefinitionSyntaxNode(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);
@@ -1942,9 +1942,9 @@ namespace Parser.Internal
     internal class AbstractMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode
     {
         internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription;
-        internal readonly CompoundNameSyntaxNode _name;
+        internal readonly CompoundNameExpressionSyntaxNode _name;
         internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription;
-        internal AbstractMethodDeclarationSyntaxNode(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription): base(TokenKind.AbstractMethodDeclaration)
+        internal AbstractMethodDeclarationSyntaxNode(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription): base(TokenKind.AbstractMethodDeclaration)
         {
             Slots = 3;
             this.AdjustWidth(outputDescription);
@@ -1955,7 +1955,7 @@ namespace Parser.Internal
             _inputDescription = inputDescription;
         }
 
-        internal AbstractMethodDeclarationSyntaxNode(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, TokenDiagnostic[] diagnostics): base(TokenKind.AbstractMethodDeclaration, diagnostics)
+        internal AbstractMethodDeclarationSyntaxNode(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, TokenDiagnostic[] diagnostics): base(TokenKind.AbstractMethodDeclaration, diagnostics)
         {
             Slots = 3;
             this.AdjustWidth(outputDescription);
@@ -2140,11 +2140,11 @@ namespace Parser.Internal
     {
         internal readonly SyntaxToken _classdefKeyword;
         internal readonly AttributeListSyntaxNode? _attributes;
-        internal readonly IdentifierNameSyntaxNode _className;
+        internal readonly IdentifierNameExpressionSyntaxNode _className;
         internal readonly BaseClassListSyntaxNode? _baseClassList;
         internal readonly SyntaxList _nodes;
         internal readonly SyntaxToken _endKeyword;
-        internal ClassDeclarationSyntaxNode(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword): base(TokenKind.ClassDeclaration)
+        internal ClassDeclarationSyntaxNode(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameExpressionSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword): base(TokenKind.ClassDeclaration)
         {
             Slots = 6;
             this.AdjustWidth(classdefKeyword);
@@ -2161,7 +2161,7 @@ namespace Parser.Internal
             _endKeyword = endKeyword;
         }
 
-        internal ClassDeclarationSyntaxNode(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ClassDeclaration, diagnostics)
+        internal ClassDeclarationSyntaxNode(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameExpressionSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ClassDeclaration, diagnostics)
         {
             Slots = 6;
             this.AdjustWidth(classdefKeyword);
@@ -2249,10 +2249,10 @@ namespace Parser.Internal
 
     internal class EnumerationItemSyntaxNode : SyntaxNode
     {
-        internal readonly IdentifierNameSyntaxNode _name;
+        internal readonly IdentifierNameExpressionSyntaxNode _name;
         internal readonly EnumerationItemValueSyntaxNode? _values;
         internal readonly SyntaxList<SyntaxToken> _commas;
-        internal EnumerationItemSyntaxNode(IdentifierNameSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList<SyntaxToken> commas): base(TokenKind.EnumerationItem)
+        internal EnumerationItemSyntaxNode(IdentifierNameExpressionSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList<SyntaxToken> commas): base(TokenKind.EnumerationItem)
         {
             Slots = 3;
             this.AdjustWidth(name);
@@ -2263,7 +2263,7 @@ namespace Parser.Internal
             _commas = commas;
         }
 
-        internal EnumerationItemSyntaxNode(IdentifierNameSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList<SyntaxToken> commas, TokenDiagnostic[] diagnostics): base(TokenKind.EnumerationItem, diagnostics)
+        internal EnumerationItemSyntaxNode(IdentifierNameExpressionSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList<SyntaxToken> commas, TokenDiagnostic[] diagnostics): base(TokenKind.EnumerationItem, diagnostics)
         {
             Slots = 3;
             this.AdjustWidth(name);
diff --git a/Parser/Internal/SyntaxNode.cs b/Parser/Internal/SyntaxNode.cs
index 5970df3..2b0a450 100644
--- a/Parser/Internal/SyntaxNode.cs
+++ b/Parser/Internal/SyntaxNode.cs
@@ -79,13 +79,13 @@ namespace Parser.Internal
         }
     }
 
-    internal abstract class FunctionHandleSyntaxNode : ExpressionSyntaxNode
+    internal abstract class FunctionHandleExpressionSyntaxNode : ExpressionSyntaxNode
     {
-        protected FunctionHandleSyntaxNode(TokenKind kind) : base(kind)
+        protected FunctionHandleExpressionSyntaxNode(TokenKind kind) : base(kind)
         {
         }
 
-        protected FunctionHandleSyntaxNode(TokenKind kind, TokenDiagnostic[] diagnostics) : base(kind, diagnostics)
+        protected FunctionHandleExpressionSyntaxNode(TokenKind kind, TokenDiagnostic[] diagnostics) : base(kind, diagnostics)
         {
         }
     }
diff --git a/SyntaxGenerator/input.xml b/Parser/SyntaxDefinition.xml
similarity index 90%
rename from SyntaxGenerator/input.xml
rename to Parser/SyntaxDefinition.xml
index 09dd3fe..7c2b538 100644
--- a/SyntaxGenerator/input.xml
+++ b/Parser/SyntaxDefinition.xml
@@ -95,24 +95,24 @@
         <Field Type="SyntaxToken" Name="operation" />
         <Field Type="ExpressionSyntaxNode" Name="operand" />
     </Class>
-    <Class Name="CompoundNameSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CompoundName">
+    <Class Name="CompoundNameExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CompoundNameExpression">
         <Field Type="SyntaxList" Name="nodes" />
     </Class>
-    <Class Name="NamedFunctionHandleSyntaxNode" BaseClass="FunctionHandleSyntaxNode" Kind="NamedFunctionHandle">
+    <Class Name="NamedFunctionHandleExpressionSyntaxNode" BaseClass="FunctionHandleExpressionSyntaxNode" Kind="NamedFunctionHandleExpression">
         <Field Type="SyntaxToken" Name="atSign" />
-        <Field Type="CompoundNameSyntaxNode" Name="functionName" />
+        <Field Type="CompoundNameExpressionSyntaxNode" Name="functionName" />
     </Class>
-    <Class Name="LambdaSyntaxNode" BaseClass="FunctionHandleSyntaxNode" Kind="Lambda">
+    <Class Name="LambdaExpressionSyntaxNode" BaseClass="FunctionHandleExpressionSyntaxNode" Kind="LambdaExpression">
         <Field Type="SyntaxToken" Name="atSign" />
         <Field Type="FunctionInputDescriptionSyntaxNode" Name="input" />
         <Field Type="ExpressionSyntaxNode" Name="body" />
     </Class>
-    <Class Name="BinaryOperationExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="BinaryOperation">
+    <Class Name="BinaryOperationExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="BinaryOperationExpression">
         <Field Type="ExpressionSyntaxNode" Name="lhs" />
         <Field Type="SyntaxToken" Name="operation" />
         <Field Type="ExpressionSyntaxNode" Name="rhs" />
     </Class>
-    <Class Name="IdentifierNameSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IdentifierName">
+    <Class Name="IdentifierNameExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IdentifierNameExpression">
         <Field Type="SyntaxToken" Name="name" />
     </Class>
     <Class Name="NumberLiteralSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="NumberLiteralExpression">
@@ -142,19 +142,19 @@
         <Field Type="ExpressionSyntaxNode" Name="expression" />
         <Field Type="SyntaxToken" Name="closingBracket" />
     </Class>
-    <Class Name="CellArrayElementAccessExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CellArrayElementAccess">
+    <Class Name="CellArrayElementAccessExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CellArrayElementAccessExpression">
         <Field Type="ExpressionSyntaxNode" Name="expression" />
         <Field Type="SyntaxToken" Name="openingBrace" />
         <Field Type="SyntaxList" Name="nodes" />
         <Field Type="SyntaxToken" Name="closingBrace" />
     </Class>
-    <Class Name="FunctionCallExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="FunctionCall">
+    <Class Name="FunctionCallExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="FunctionCallExpression">
         <Field Type="ExpressionSyntaxNode" Name="functionName" />
         <Field Type="SyntaxToken" Name="openingBracket" />
         <Field Type="SyntaxList" Name="nodes" />
         <Field Type="SyntaxToken" Name="closingBracket" />
     </Class>
-    <Class Name="MemberAccessSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="MemberAccess">
+    <Class Name="MemberAccessSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="MemberAccessExpression">
         <Field Type="SyntaxNode" Name="leftOperand" />
         <Field Type="SyntaxToken" Name="dot" />
         <Field Type="SyntaxNode" Name="rightOperand" />
@@ -163,16 +163,16 @@
         <Field Type="ExpressionSyntaxNode" Name="operand" />
         <Field Type="SyntaxToken" Name="operation" />
     </Class>
-    <Class Name="IndirectMemberAccessSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IndirectMemberAccess">
+    <Class Name="IndirectMemberAccessSyntaxNode" 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="Command">
-        <Field Type="IdentifierNameSyntaxNode" Name="commandName" />
+    <Class Name="CommandExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CommandExpression">
+        <Field Type="IdentifierNameExpressionSyntaxNode" Name="commandName" />
         <Field Type="SyntaxList&lt;UnquotedStringLiteralSyntaxNode&gt;" Name="arguments" />
     </Class>
-    <Class Name="BaseClassInvokationSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="ClassInvokation">
+    <Class Name="BaseClassInvokationSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="ClassInvokationExpression">
         <Field Type="ExpressionSyntaxNode" Name="methodName" />
         <Field Type="SyntaxToken" Name="atSign" />
         <Field Type="ExpressionSyntaxNode" Name="baseClassNameAndArguments" />
@@ -182,7 +182,7 @@
         <Field Type="ExpressionSyntaxNode" Name="value" />
     </Class>
     <Class Name="AttributeSyntaxNode" BaseClass="SyntaxNode" Kind="Attribute">
-        <Field Type="IdentifierNameSyntaxNode" Name="name" />
+        <Field Type="IdentifierNameExpressionSyntaxNode" Name="name" />
         <Field Type="AttributeAssignmentSyntaxNode" Name="assignment" Nullable="true" />
     </Class>
     <Class Name="AttributeListSyntaxNode" BaseClass="SyntaxNode" Kind="AttributeList">
@@ -190,10 +190,10 @@
         <Field Type="SyntaxList" Name="nodes" />
         <Field Type="SyntaxToken" Name="closingBracket" />
     </Class>
-    <Class Name="MethodDefinitionSyntaxNode" BaseClass="MethodDeclarationSyntaxNode" Kind="MethodDefinition">
+    <Class Name="MethodDefinitionSyntaxNode" BaseClass="MethodDeclarationSyntaxNode" Kind="ConcreteMethodDeclaration">
         <Field Type="SyntaxToken" Name="functionKeyword" />
         <Field Type="FunctionOutputDescriptionSyntaxNode" Name="outputDescription" Nullable="true" />
-        <Field Type="CompoundNameSyntaxNode" Name="name" />
+        <Field Type="CompoundNameExpressionSyntaxNode" Name="name" />
         <Field Type="FunctionInputDescriptionSyntaxNode" Name="inputDescription" Nullable="true"/>
         <Field Type="SyntaxList&lt;SyntaxToken&gt;" Name="commas" />
         <Field Type="SyntaxList" Name="body" />
@@ -201,7 +201,7 @@
     </Class>
     <Class Name="AbstractMethodDeclarationSyntaxNode" BaseClass="MethodDeclarationSyntaxNode" Kind="AbstractMethodDeclaration">
         <Field Type="FunctionOutputDescriptionSyntaxNode" Name="outputDescription" Nullable="true" />
-        <Field Type="CompoundNameSyntaxNode" Name="name" />
+        <Field Type="CompoundNameExpressionSyntaxNode" Name="name" />
         <Field Type="FunctionInputDescriptionSyntaxNode" Name="inputDescription" Nullable="true"/>
     </Class>
     <Class Name="MethodsListSyntaxNode" BaseClass="SyntaxNode" Kind="MethodsList">
@@ -223,7 +223,7 @@
     <Class Name="ClassDeclarationSyntaxNode" BaseClass="StatementSyntaxNode" Kind="ClassDeclaration">
         <Field Type="SyntaxToken" Name="classdefKeyword" />
         <Field Type="AttributeListSyntaxNode" Name="attributes" Nullable="true" />
-        <Field Type="IdentifierNameSyntaxNode" Name="className" />
+        <Field Type="IdentifierNameExpressionSyntaxNode" Name="className" />
         <Field Type="BaseClassListSyntaxNode" Name="baseClassList" Nullable="true" />
         <Field Type="SyntaxList" Name="nodes" />
         <Field Type="SyntaxToken" Name="endKeyword" />
@@ -234,7 +234,7 @@
         <Field Type="SyntaxToken" Name="closingBracket" />
     </Class>
     <Class Name="EnumerationItemSyntaxNode" BaseClass="SyntaxNode" Kind="EnumerationItem">
-        <Field Type="IdentifierNameSyntaxNode" Name="name" />
+        <Field Type="IdentifierNameExpressionSyntaxNode" Name="name" />
         <Field Type="EnumerationItemValueSyntaxNode" Name="values" Nullable="true"/>
         <Field Type="SyntaxList&lt;SyntaxToken&gt;" Name="commas" />
     </Class>
diff --git a/Parser/SyntaxNode.Generated.cs b/Parser/SyntaxNode.Generated.cs
index 105fac7..96c114e 100644
--- a/Parser/SyntaxNode.Generated.cs
+++ b/Parser/SyntaxNode.Generated.cs
@@ -941,10 +941,10 @@ namespace Parser
         }
     }
 
-    public class CompoundNameSyntaxNode : ExpressionSyntaxNode
+    public class CompoundNameExpressionSyntaxNode : ExpressionSyntaxNode
     {
         private SyntaxNode? _nodes;
-        internal CompoundNameSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
+        internal CompoundNameExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
         {
         }
 
@@ -969,14 +969,14 @@ namespace Parser
 
         public override void Accept(SyntaxVisitor visitor)
         {
-            visitor.VisitCompoundName(this);
+            visitor.VisitCompoundNameExpression(this);
         }
     }
 
-    public class NamedFunctionHandleSyntaxNode : FunctionHandleSyntaxNode
+    public class NamedFunctionHandleExpressionSyntaxNode : FunctionHandleExpressionSyntaxNode
     {
         private SyntaxNode? _functionName;
-        internal NamedFunctionHandleSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
+        internal NamedFunctionHandleExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
         {
         }
 
@@ -984,16 +984,16 @@ namespace Parser
         {
             get
             {
-                return new SyntaxToken(this, ((Parser.Internal.NamedFunctionHandleSyntaxNode)_green)._atSign, this.GetChildPosition(0));
+                return new SyntaxToken(this, ((Parser.Internal.NamedFunctionHandleExpressionSyntaxNode)_green)._atSign, this.GetChildPosition(0));
             }
         }
 
-        public CompoundNameSyntaxNode FunctionName
+        public CompoundNameExpressionSyntaxNode FunctionName
         {
             get
             {
                 var red = this.GetRed(ref this._functionName!, 1);
-                return red is null ? throw new System.Exception("functionName cannot be null.") : (CompoundNameSyntaxNode)red;
+                return red is null ? throw new System.Exception("functionName cannot be null.") : (CompoundNameExpressionSyntaxNode)red;
             }
         }
 
@@ -1009,15 +1009,15 @@ namespace Parser
 
         public override void Accept(SyntaxVisitor visitor)
         {
-            visitor.VisitNamedFunctionHandle(this);
+            visitor.VisitNamedFunctionHandleExpression(this);
         }
     }
 
-    public class LambdaSyntaxNode : FunctionHandleSyntaxNode
+    public class LambdaExpressionSyntaxNode : FunctionHandleExpressionSyntaxNode
     {
         private SyntaxNode? _input;
         private SyntaxNode? _body;
-        internal LambdaSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
+        internal LambdaExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
         {
         }
 
@@ -1025,7 +1025,7 @@ namespace Parser
         {
             get
             {
-                return new SyntaxToken(this, ((Parser.Internal.LambdaSyntaxNode)_green)._atSign, this.GetChildPosition(0));
+                return new SyntaxToken(this, ((Parser.Internal.LambdaExpressionSyntaxNode)_green)._atSign, this.GetChildPosition(0));
             }
         }
 
@@ -1059,7 +1059,7 @@ namespace Parser
 
         public override void Accept(SyntaxVisitor visitor)
         {
-            visitor.VisitLambda(this);
+            visitor.VisitLambdaExpression(this);
         }
     }
 
@@ -1113,9 +1113,9 @@ namespace Parser
         }
     }
 
-    public class IdentifierNameSyntaxNode : ExpressionSyntaxNode
+    public class IdentifierNameExpressionSyntaxNode : ExpressionSyntaxNode
     {
-        internal IdentifierNameSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
+        internal IdentifierNameExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
         {
         }
 
@@ -1123,7 +1123,7 @@ namespace Parser
         {
             get
             {
-                return new SyntaxToken(this, ((Parser.Internal.IdentifierNameSyntaxNode)_green)._name, this.GetChildPosition(0));
+                return new SyntaxToken(this, ((Parser.Internal.IdentifierNameExpressionSyntaxNode)_green)._name, this.GetChildPosition(0));
             }
         }
 
@@ -1139,7 +1139,7 @@ namespace Parser
 
         public override void Accept(SyntaxVisitor visitor)
         {
-            visitor.VisitIdentifierName(this);
+            visitor.VisitIdentifierNameExpression(this);
         }
     }
 
@@ -1669,12 +1669,12 @@ namespace Parser
         {
         }
 
-        public IdentifierNameSyntaxNode CommandName
+        public IdentifierNameExpressionSyntaxNode CommandName
         {
             get
             {
                 var red = this.GetRed(ref this._commandName!, 0);
-                return red is null ? throw new System.Exception("commandName cannot be null.") : (IdentifierNameSyntaxNode)red;
+                return red is null ? throw new System.Exception("commandName cannot be null.") : (IdentifierNameExpressionSyntaxNode)red;
             }
         }
 
@@ -1801,12 +1801,12 @@ namespace Parser
         {
         }
 
-        public IdentifierNameSyntaxNode Name
+        public IdentifierNameExpressionSyntaxNode Name
         {
             get
             {
                 var red = this.GetRed(ref this._name!, 0);
-                return red is null ? throw new System.Exception("name cannot be null.") : (IdentifierNameSyntaxNode)red;
+                return red is null ? throw new System.Exception("name cannot be null.") : (IdentifierNameExpressionSyntaxNode)red;
             }
         }
 
@@ -1912,12 +1912,12 @@ namespace Parser
             }
         }
 
-        public CompoundNameSyntaxNode Name
+        public CompoundNameExpressionSyntaxNode Name
         {
             get
             {
                 var red = this.GetRed(ref this._name!, 2);
-                return red is null ? throw new System.Exception("name cannot be null.") : (CompoundNameSyntaxNode)red;
+                return red is null ? throw new System.Exception("name cannot be null.") : (CompoundNameExpressionSyntaxNode)red;
             }
         }
 
@@ -1991,12 +1991,12 @@ namespace Parser
             }
         }
 
-        public CompoundNameSyntaxNode Name
+        public CompoundNameExpressionSyntaxNode Name
         {
             get
             {
                 var red = this.GetRed(ref this._name!, 1);
-                return red is null ? throw new System.Exception("name cannot be null.") : (CompoundNameSyntaxNode)red;
+                return red is null ? throw new System.Exception("name cannot be null.") : (CompoundNameExpressionSyntaxNode)red;
             }
         }
 
@@ -2216,12 +2216,12 @@ namespace Parser
             }
         }
 
-        public IdentifierNameSyntaxNode ClassName
+        public IdentifierNameExpressionSyntaxNode ClassName
         {
             get
             {
                 var red = this.GetRed(ref this._className!, 2);
-                return red is null ? throw new System.Exception("className cannot be null.") : (IdentifierNameSyntaxNode)red;
+                return red is null ? throw new System.Exception("className cannot be null.") : (IdentifierNameExpressionSyntaxNode)red;
             }
         }
 
@@ -2316,12 +2316,12 @@ namespace Parser
         {
         }
 
-        public IdentifierNameSyntaxNode Name
+        public IdentifierNameExpressionSyntaxNode Name
         {
             get
             {
                 var red = this.GetRed(ref this._name!, 0);
-                return red is null ? throw new System.Exception("name cannot be null.") : (IdentifierNameSyntaxNode)red;
+                return red is null ? throw new System.Exception("name cannot be null.") : (IdentifierNameExpressionSyntaxNode)red;
             }
         }
 
diff --git a/Parser/SyntaxNode.cs b/Parser/SyntaxNode.cs
index e3db3e6..e7eb31e 100644
--- a/Parser/SyntaxNode.cs
+++ b/Parser/SyntaxNode.cs
@@ -141,9 +141,9 @@ namespace Parser
         }
     }
 
-    public abstract class FunctionHandleSyntaxNode : ExpressionSyntaxNode
+    public abstract class FunctionHandleExpressionSyntaxNode : ExpressionSyntaxNode
     {
-        internal FunctionHandleSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
+        internal FunctionHandleExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
         {
         }
     }
diff --git a/Parser/SyntaxVisitor.Generated.cs b/Parser/SyntaxVisitor.Generated.cs
index 3ee82f6..b16d17b 100644
--- a/Parser/SyntaxVisitor.Generated.cs
+++ b/Parser/SyntaxVisitor.Generated.cs
@@ -93,17 +93,17 @@ namespace Parser
             DefaultVisit(node);
         }
 
-        public virtual void VisitCompoundName(CompoundNameSyntaxNode node)
+        public virtual void VisitCompoundNameExpression(CompoundNameExpressionSyntaxNode node)
         {
             DefaultVisit(node);
         }
 
-        public virtual void VisitNamedFunctionHandle(NamedFunctionHandleSyntaxNode node)
+        public virtual void VisitNamedFunctionHandleExpression(NamedFunctionHandleExpressionSyntaxNode node)
         {
             DefaultVisit(node);
         }
 
-        public virtual void VisitLambda(LambdaSyntaxNode node)
+        public virtual void VisitLambdaExpression(LambdaExpressionSyntaxNode node)
         {
             DefaultVisit(node);
         }
@@ -113,7 +113,7 @@ namespace Parser
             DefaultVisit(node);
         }
 
-        public virtual void VisitIdentifierName(IdentifierNameSyntaxNode node)
+        public virtual void VisitIdentifierNameExpression(IdentifierNameExpressionSyntaxNode node)
         {
             DefaultVisit(node);
         }
diff --git a/Parser/TokenKind.cs b/Parser/TokenKind.cs
index 52e455c..c1b403e 100644
--- a/Parser/TokenKind.cs
+++ b/Parser/TokenKind.cs
@@ -3,7 +3,9 @@
     // We use the same set of kinds for syntax tokens & syntax nodes.
     public enum TokenKind
     {
-        // SYNTAX TOKENS
+        // *****************
+        // * SYNTAX TOKENS *
+        // *****************
 
         None = 0,
         BadToken = 1,
@@ -123,31 +125,54 @@
         UnaryNot = 59,
         UnaryQuestionMark = 60,
 
-        // SYNTAX NODES
+        // ****************
+        // * SYNTAX NODES *
+        // ****************
+
         // The whole file.
         File = 100,
+
         // a list of syntax nodes and/or tokens.
         List,
+
+
+        // STATEMENTS
+        // The name ends with "Declaration" or "Statement".
+
+        // result = abstractMethod(object)
+        AbstractMethodDeclaration,
+
+        // classdef MyClass < BaseClass, AnotherBaseClass
+        //     properties
+        //         y
+        //     end
+        //     methods
+        //         <...>
+        //     end
+        // end
+        ClassDeclaration,
+
+        // function result = method(obj)
+        //     <...>
+        // end
+        ConcreteMethodDeclaration,
+
+        // 
+        EmptyStatement,
+
+        // a = 5;
+        ExpressionStatement,
+
+        // for a = 1:5
+        //     process(a);
+        // end
+        ForStatement,
+
         // [output1, output2] = function(input1, input2)
         // <...>
         // end
         FunctionDeclaration,
-        // (input1, input2)
-        FunctionInputDescription,
-        // [output1, output2] =
-        FunctionOutputDescription,
-        // switch a
-        //     case 1
-        // <...>
-        // end
-        SwitchStatement,
-        // case 1
-        //     doSomething();
-        SwitchCase,
-        // while a < 10
-        //     doSomething();
-        // end
-        WhileStatement,
+
         // if a < 5
         //     doSomething();
         // elseif a > 10
@@ -156,84 +181,125 @@
         //     GiveUp();
         // end
         IfStatement,
-        // elseif a > 10
-        //     doSomethingElse();
-        ElseifClause,
-        // else
-        //     GiveUp();
-        ElseClause,
-        // for a = 1:5
-        //     process(a);
+
+        // switch a
+        //     case 1
+        // <...>
         // end
-        ForStatement,
-        // a = 1:5
-        AssignmentExpression,
-        // catch e
-        //     dealWithIt(e);
-        // end
-        CatchClause,
+        SwitchStatement,
+
         // try
         //     somethingWeird();
         // catch e
         //     dealWithIt(e);
         // end
         TryCatchStatement,
-        // a = 5;
-        ExpressionStatement,
-        // 
-        EmptyStatement,
-        // 
-        EmptyExpression,
-        // -13
-        UnaryPrefixOperationExpression,
-        // some.complex.name
-        CompoundName,
-        // @func
-        NamedFunctionHandle,
-        // @(x) x + 1
-        Lambda,
-        // +
-        BinaryOperation,
-        // a
-        IdentifierName,
-        // 123
-        NumberLiteralExpression,
-        // 'abc'
-        StringLiteralExpression,
-        // "abc"
-        DoubleQuotedStringLiteralExpression,
-        // abc
-        UnquotedStringLiteralExpression,
+
+        // while a < 10
+        //     doSomething();
+        // end
+        WhileStatement,
+
+
+        // EXPRESSIONS
+        // The name ends with "Expression".
+
         // [1, 2; 3 4]
         ArrayLiteralExpression,
+
+        // a = 1:5
+        AssignmentExpression,
+
+        // +
+        BinaryOperationExpression,
+
+        // abc{2}
+        CellArrayElementAccessExpression,
+
         // {1, 3, 'abc'}
         CellArrayLiteralExpression,
+
+        // method@SuperClass(object)
+        ClassInvokationExpression,
+
+        // cd some/+folder/
+        CommandExpression,
+
+        // some.complex.name
+        CompoundNameExpression,
+
+        // "abc"
+        DoubleQuotedStringLiteralExpression,
+
+        // 
+        EmptyExpression,
+
+        // doSomething(5)
+        FunctionCallExpression,
+
+        // a
+        IdentifierNameExpression,
+
+        // struct.(field)
+        IndirectMemberAccessExpression,
+
+        // @(x) x + 1
+        LambdaExpression,
+
+        // object.member
+        MemberAccessExpression,
+
+        // @func
+        NamedFunctionHandleExpression,
+
+        // 123
+        NumberLiteralExpression,
+
         // (1 + 2 * 3)
         ParenthesizedExpression,
-        // abc{2}
-        CellArrayElementAccess,
-        // doSomething(5)
-        FunctionCall,
-        // object.member
-        MemberAccess,
+
+        // 'abc'
+        StringLiteralExpression,
+
+        // -13
+        UnaryPrefixOperationExpression,
+
         // [1 2 3]'
         UnaryPostfixOperationExpression,
-        // struct.(field)
-        IndirectMemberAccess,
-        // cd some/+folder/
-        Command,
-        // method@SuperClass(object)
-        ClassInvokation,
+
+        // abc
+        UnquotedStringLiteralExpression,
+
+
+        // PARTS OF STATEMENTS & EXPRESSIONS
+
+        // (input1, input2)
+        FunctionInputDescription,
+        // [output1, output2] =
+        FunctionOutputDescription,
+
+        // case 1
+        //     doSomething();
+        SwitchCase,
+
+        // elseif a > 10
+        //     doSomethingElse();
+        ElseifClause,
+        // else
+        //     GiveUp();
+        ElseClause,
+        // catch e
+        //     dealWithIt(e);
+        // end
+        CatchClause,
+
         // = true
         AttributeAssignment,
         // Sealed = true
         Attribute,
         // (Sealed = true)
         AttributeList,
-        // function result = method(obj)
-        //     <...>
-        // end
-        MethodDefinition,
+
         // methods
         //     function result = method(obj)
         //     <...>
@@ -247,15 +313,7 @@
         PropertiesList,
         // < BaseClass, AnotherBaseClass
         BaseClassList,
-        // classdef MyClass < BaseClass, AnotherBaseClass
-        //     properties
-        //         y
-        //     end
-        //     methods
-        //         <...>
-        //     end
-        // end
-        ClassDeclaration,
+
         // (1)
         EnumerationItemValue,
         // One (1)
@@ -265,8 +323,6 @@
         //     Two (2)
         // end
         EnumerationList,
-        // result = abstractMethod(object)
-        AbstractMethodDeclaration,
         // events
         //     ToggleSomething
         // end
diff --git a/SyntaxGenerator/GenerateSyntax.cs b/SyntaxGenerator/GenerateSyntax.cs
index 847da49..ddb8c6f 100644
--- a/SyntaxGenerator/GenerateSyntax.cs
+++ b/SyntaxGenerator/GenerateSyntax.cs
@@ -844,7 +844,8 @@ namespace SyntaxGenerator
         public static void Input()
         {
             var serializer = new XmlSerializer(typeof(SyntaxDescription));
-            using var stream = new FileStream("input.xml", FileMode.Open);
+            var syntaxDefinitionFileName = Path.Combine(_outputPath, "SyntaxDefinition.xml");
+            using var stream = new FileStream(syntaxDefinitionFileName, FileMode.Open);
             if (!(serializer.Deserialize(stream) is SyntaxDescription syntax))
             {
                 Console.WriteLine("Couldn't deserialize syntax.");