Use Roslyn in SyntaxGenerator

Parser/Internal/SyntaxFactory.Generated.cs

@@ -3,198 +3,84 @@ namespace Parser.Internal
 {
     internal partial class SyntaxFactory
     {
-        public FileSyntaxNode FileSyntax(
+        public FileSyntaxNode FileSyntax(SyntaxList statementList, SyntaxToken endOfFile)
-            SyntaxList statementList, 
-            SyntaxToken endOfFile)
         {
-            return new FileSyntaxNode(
+            return new FileSyntaxNode(statementList, endOfFile);
-                statementList, 
-                endOfFile);
         }
 
-        public FunctionDeclarationSyntaxNode FunctionDeclarationSyntax(
+        public FunctionDeclarationSyntaxNode FunctionDeclarationSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword)
-            SyntaxToken functionKeyword, 
-            FunctionOutputDescriptionSyntaxNode? outputDescription, 
-            SyntaxToken name, 
-            FunctionInputDescriptionSyntaxNode? inputDescription, 
-            SyntaxList<SyntaxToken> commas, 
-            SyntaxList body, 
-            EndKeywordSyntaxNode? endKeyword)
         {
-            return new FunctionDeclarationSyntaxNode(
+            return new FunctionDeclarationSyntaxNode(functionKeyword, outputDescription, name, inputDescription, commas, body, endKeyword);
-                functionKeyword, 
-                outputDescription, 
-                name, 
-                inputDescription, 
-                commas, 
-                body, 
-                endKeyword);
         }
 
-        public FunctionOutputDescriptionSyntaxNode FunctionOutputDescriptionSyntax(
+        public FunctionOutputDescriptionSyntaxNode FunctionOutputDescriptionSyntax(SyntaxList outputList, SyntaxToken assignmentSign)
-            SyntaxList outputList, 
-            SyntaxToken assignmentSign)
         {
-            return new FunctionOutputDescriptionSyntaxNode(
+            return new FunctionOutputDescriptionSyntaxNode(outputList, assignmentSign);
-                outputList, 
-                assignmentSign);
         }
 
-        public FunctionInputDescriptionSyntaxNode FunctionInputDescriptionSyntax(
+        public FunctionInputDescriptionSyntaxNode FunctionInputDescriptionSyntax(SyntaxToken openingBracket, SyntaxList parameterList, SyntaxToken closingBracket)
-            SyntaxToken openingBracket, 
-            SyntaxList parameterList, 
-            SyntaxToken closingBracket)
         {
-            return new FunctionInputDescriptionSyntaxNode(
+            return new FunctionInputDescriptionSyntaxNode(openingBracket, parameterList, closingBracket);
-                openingBracket, 
-                parameterList, 
-                closingBracket);
         }
 
-        public SwitchStatementSyntaxNode SwitchStatementSyntax(
+        public SwitchStatementSyntaxNode SwitchStatementSyntax(SyntaxToken switchKeyword, ExpressionSyntaxNode switchExpression, SyntaxList<SyntaxToken> optionalCommas, SyntaxList<SwitchCaseSyntaxNode> cases, SyntaxToken endKeyword)
-            SyntaxToken switchKeyword, 
-            ExpressionSyntaxNode switchExpression, 
-            SyntaxList<SyntaxToken> optionalCommas, 
-            SyntaxList<SwitchCaseSyntaxNode> cases, 
-            SyntaxToken endKeyword)
         {
-            return new SwitchStatementSyntaxNode(
+            return new SwitchStatementSyntaxNode(switchKeyword, switchExpression, optionalCommas, cases, endKeyword);
-                switchKeyword, 
-                switchExpression, 
-                optionalCommas, 
-                cases, 
-                endKeyword);
         }
 
-        public SwitchCaseSyntaxNode SwitchCaseSyntax(
+        public SwitchCaseSyntaxNode SwitchCaseSyntax(SyntaxToken caseKeyword, ExpressionSyntaxNode caseIdentifier, SyntaxList<SyntaxToken> optionalCommas, SyntaxList body)
-            SyntaxToken caseKeyword, 
-            ExpressionSyntaxNode caseIdentifier, 
-            SyntaxList<SyntaxToken> optionalCommas, 
-            SyntaxList body)
         {
-            return new SwitchCaseSyntaxNode(
+            return new SwitchCaseSyntaxNode(caseKeyword, caseIdentifier, optionalCommas, body);
-                caseKeyword, 
-                caseIdentifier, 
-                optionalCommas, 
-                body);
         }
 
-        public WhileStatementSyntaxNode WhileStatementSyntax(
+        public WhileStatementSyntaxNode WhileStatementSyntax(SyntaxToken whileKeyword, ExpressionSyntaxNode condition, SyntaxList<SyntaxToken> optionalCommas, SyntaxList body, SyntaxToken endKeyword)
-            SyntaxToken whileKeyword, 
-            ExpressionSyntaxNode condition, 
-            SyntaxList<SyntaxToken> optionalCommas, 
-            SyntaxList body, 
-            SyntaxToken endKeyword)
         {
-            return new WhileStatementSyntaxNode(
+            return new WhileStatementSyntaxNode(whileKeyword, condition, optionalCommas, body, endKeyword);
-                whileKeyword, 
-                condition, 
-                optionalCommas, 
-                body, 
-                endKeyword);
         }
 
-        public ElseifClause ElseifClause(
+        public ElseifClause ElseifClause(SyntaxToken elseifKeyword, ExpressionSyntaxNode condition, SyntaxList<SyntaxToken> optionalCommas, SyntaxList body)
-            SyntaxToken elseifKeyword, 
-            ExpressionSyntaxNode condition, 
-            SyntaxList<SyntaxToken> optionalCommas, 
-            SyntaxList body)
         {
-            return new ElseifClause(
+            return new ElseifClause(elseifKeyword, condition, optionalCommas, body);
-                elseifKeyword, 
-                condition, 
-                optionalCommas, 
-                body);
         }
 
-        public ElseClause ElseClause(
+        public ElseClause ElseClause(SyntaxToken elseKeyword, SyntaxList body)
-            SyntaxToken elseKeyword, 
-            SyntaxList body)
         {
-            return new ElseClause(
+            return new ElseClause(elseKeyword, body);
-                elseKeyword, 
-                body);
         }
 
-        public IfStatementSyntaxNode IfStatementSyntax(
+        public IfStatementSyntaxNode IfStatementSyntax(SyntaxToken ifKeyword, ExpressionSyntaxNode condition, SyntaxList<SyntaxToken> optionalCommas, SyntaxList body, SyntaxList<ElseifClause> elseifClauses, ElseClause? elseClause, SyntaxToken endKeyword)
-            SyntaxToken ifKeyword, 
-            ExpressionSyntaxNode condition, 
-            SyntaxList<SyntaxToken> optionalCommas, 
-            SyntaxList body, 
-            SyntaxList<ElseifClause> elseifClauses, 
-            ElseClause? elseClause, 
-            SyntaxToken endKeyword)
         {
-            return new IfStatementSyntaxNode(
+            return new IfStatementSyntaxNode(ifKeyword, condition, optionalCommas, body, elseifClauses, elseClause, endKeyword);
-                ifKeyword, 
-                condition, 
-                optionalCommas, 
-                body, 
-                elseifClauses, 
-                elseClause, 
-                endKeyword);
         }
 
-        public ForStatementSyntaxNode ForStatementSyntax(
+        public ForStatementSyntaxNode ForStatementSyntax(SyntaxToken forKeyword, AssignmentExpressionSyntaxNode assignment, SyntaxList<SyntaxToken> optionalCommas, SyntaxList body, SyntaxToken endKeyword)
-            SyntaxToken forKeyword, 
-            AssignmentExpressionSyntaxNode assignment, 
-            SyntaxList<SyntaxToken> optionalCommas, 
-            SyntaxList body, 
-            SyntaxToken endKeyword)
         {
-            return new ForStatementSyntaxNode(
+            return new ForStatementSyntaxNode(forKeyword, assignment, optionalCommas, body, endKeyword);
-                forKeyword, 
-                assignment, 
-                optionalCommas, 
-                body, 
-                endKeyword);
         }
 
-        public AssignmentExpressionSyntaxNode AssignmentExpressionSyntax(
+        public AssignmentExpressionSyntaxNode AssignmentExpressionSyntax(ExpressionSyntaxNode lhs, SyntaxToken assignmentSign, ExpressionSyntaxNode rhs)
-            ExpressionSyntaxNode lhs, 
-            SyntaxToken assignmentSign, 
-            ExpressionSyntaxNode rhs)
         {
-            return new AssignmentExpressionSyntaxNode(
+            return new AssignmentExpressionSyntaxNode(lhs, assignmentSign, rhs);
-                lhs, 
-                assignmentSign, 
-                rhs);
         }
 
-        public CatchClauseSyntaxNode CatchClauseSyntax(
+        public CatchClauseSyntaxNode CatchClauseSyntax(SyntaxToken catchKeyword, SyntaxList catchBody)
-            SyntaxToken catchKeyword, 
-            SyntaxList catchBody)
         {
-            return new CatchClauseSyntaxNode(
+            return new CatchClauseSyntaxNode(catchKeyword, catchBody);
-                catchKeyword, 
-                catchBody);
         }
 
-        public TryCatchStatementSyntaxNode TryCatchStatementSyntax(
+        public TryCatchStatementSyntaxNode TryCatchStatementSyntax(SyntaxToken tryKeyword, SyntaxList tryBody, CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword)
-            SyntaxToken tryKeyword, 
-            SyntaxList tryBody, 
-            CatchClauseSyntaxNode? catchClause, 
-            SyntaxToken endKeyword)
         {
-            return new TryCatchStatementSyntaxNode(
+            return new TryCatchStatementSyntaxNode(tryKeyword, tryBody, catchClause, endKeyword);
-                tryKeyword, 
-                tryBody, 
-                catchClause, 
-                endKeyword);
         }
 
-        public ExpressionStatementSyntaxNode ExpressionStatementSyntax(
+        public ExpressionStatementSyntaxNode ExpressionStatementSyntax(ExpressionSyntaxNode expression)
-            ExpressionSyntaxNode expression)
         {
-            return new ExpressionStatementSyntaxNode(
+            return new ExpressionStatementSyntaxNode(expression);
-                expression);
         }
 
-        public EmptyStatementSyntaxNode EmptyStatementSyntax(
+        public EmptyStatementSyntaxNode EmptyStatementSyntax(SyntaxToken semicolon)
-            SyntaxToken semicolon)
         {
-            return new EmptyStatementSyntaxNode(
+            return new EmptyStatementSyntaxNode(semicolon);
-                semicolon);
         }
 
         public EmptyExpressionSyntaxNode EmptyExpressionSyntax()
@@ -202,362 +88,174 @@ namespace Parser.Internal
             return new EmptyExpressionSyntaxNode();
         }
 
-        public UnaryPrefixOperationExpressionSyntaxNode UnaryPrefixOperationExpressionSyntax(
+        public UnaryPrefixOperationExpressionSyntaxNode UnaryPrefixOperationExpressionSyntax(SyntaxToken operation, ExpressionSyntaxNode operand)
-            SyntaxToken operation, 
-            ExpressionSyntaxNode operand)
         {
-            return new UnaryPrefixOperationExpressionSyntaxNode(
+            return new UnaryPrefixOperationExpressionSyntaxNode(operation, operand);
-                operation, 
-                operand);
         }
 
-        public CompoundNameSyntaxNode CompoundNameSyntax(
+        public CompoundNameSyntaxNode CompoundNameSyntax(SyntaxList nodes)
-            SyntaxList nodes)
         {
-            return new CompoundNameSyntaxNode(
+            return new CompoundNameSyntaxNode(nodes);
-                nodes);
         }
 
-        public NamedFunctionHandleSyntaxNode NamedFunctionHandleSyntax(
+        public NamedFunctionHandleSyntaxNode NamedFunctionHandleSyntax(SyntaxToken atSign, CompoundNameSyntaxNode functionName)
-            SyntaxToken atSign, 
-            CompoundNameSyntaxNode functionName)
         {
-            return new NamedFunctionHandleSyntaxNode(
+            return new NamedFunctionHandleSyntaxNode(atSign, functionName);
-                atSign, 
-                functionName);
         }
 
-        public LambdaSyntaxNode LambdaSyntax(
+        public LambdaSyntaxNode LambdaSyntax(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body)
-            SyntaxToken atSign, 
-            FunctionInputDescriptionSyntaxNode input, 
-            ExpressionSyntaxNode body)
         {
-            return new LambdaSyntaxNode(
+            return new LambdaSyntaxNode(atSign, input, body);
-                atSign, 
-                input, 
-                body);
         }
 
-        public BinaryOperationExpressionSyntaxNode BinaryOperationExpressionSyntax(
+        public BinaryOperationExpressionSyntaxNode BinaryOperationExpressionSyntax(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs)
-            ExpressionSyntaxNode lhs, 
-            SyntaxToken operation, 
-            ExpressionSyntaxNode rhs)
         {
-            return new BinaryOperationExpressionSyntaxNode(
+            return new BinaryOperationExpressionSyntaxNode(lhs, operation, rhs);
-                lhs, 
-                operation, 
-                rhs);
         }
 
-        public IdentifierNameSyntaxNode IdentifierNameSyntax(
+        public IdentifierNameSyntaxNode IdentifierNameSyntax(SyntaxToken name)
-            SyntaxToken name)
         {
-            return new IdentifierNameSyntaxNode(
+            return new IdentifierNameSyntaxNode(name);
-                name);
         }
 
-        public NumberLiteralSyntaxNode NumberLiteralSyntax(
+        public NumberLiteralSyntaxNode NumberLiteralSyntax(SyntaxToken number)
-            SyntaxToken number)
         {
-            return new NumberLiteralSyntaxNode(
+            return new NumberLiteralSyntaxNode(number);
-                number);
         }
 
-        public StringLiteralSyntaxNode StringLiteralSyntax(
+        public StringLiteralSyntaxNode StringLiteralSyntax(SyntaxToken stringToken)
-            SyntaxToken stringToken)
         {
-            return new StringLiteralSyntaxNode(
+            return new StringLiteralSyntaxNode(stringToken);
-                stringToken);
         }
 
-        public DoubleQuotedStringLiteralSyntaxNode DoubleQuotedStringLiteralSyntax(
+        public DoubleQuotedStringLiteralSyntaxNode DoubleQuotedStringLiteralSyntax(SyntaxToken stringToken)
-            SyntaxToken stringToken)
         {
-            return new DoubleQuotedStringLiteralSyntaxNode(
+            return new DoubleQuotedStringLiteralSyntaxNode(stringToken);
-                stringToken);
         }
 
-        public UnquotedStringLiteralSyntaxNode UnquotedStringLiteralSyntax(
+        public UnquotedStringLiteralSyntaxNode UnquotedStringLiteralSyntax(SyntaxToken stringToken)
-            SyntaxToken stringToken)
         {
-            return new UnquotedStringLiteralSyntaxNode(
+            return new UnquotedStringLiteralSyntaxNode(stringToken);
-                stringToken);
         }
 
-        public ArrayLiteralExpressionSyntaxNode ArrayLiteralExpressionSyntax(
+        public ArrayLiteralExpressionSyntaxNode ArrayLiteralExpressionSyntax(SyntaxToken openingSquareBracket, SyntaxList nodes, SyntaxToken closingSquareBracket)
-            SyntaxToken openingSquareBracket, 
-            SyntaxList nodes, 
-            SyntaxToken closingSquareBracket)
         {
-            return new ArrayLiteralExpressionSyntaxNode(
+            return new ArrayLiteralExpressionSyntaxNode(openingSquareBracket, nodes, closingSquareBracket);
-                openingSquareBracket, 
-                nodes, 
-                closingSquareBracket);
         }
 
-        public CellArrayLiteralExpressionSyntaxNode CellArrayLiteralExpressionSyntax(
+        public CellArrayLiteralExpressionSyntaxNode CellArrayLiteralExpressionSyntax(SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace)
-            SyntaxToken openingBrace, 
-            SyntaxList nodes, 
-            SyntaxToken closingBrace)
         {
-            return new CellArrayLiteralExpressionSyntaxNode(
+            return new CellArrayLiteralExpressionSyntaxNode(openingBrace, nodes, closingBrace);
-                openingBrace, 
-                nodes, 
-                closingBrace);
         }
 
-        public ParenthesizedExpressionSyntaxNode ParenthesizedExpressionSyntax(
+        public ParenthesizedExpressionSyntaxNode ParenthesizedExpressionSyntax(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket)
-            SyntaxToken openingBracket, 
-            ExpressionSyntaxNode expression, 
-            SyntaxToken closingBracket)
         {
-            return new ParenthesizedExpressionSyntaxNode(
+            return new ParenthesizedExpressionSyntaxNode(openingBracket, expression, closingBracket);
-                openingBracket, 
-                expression, 
-                closingBracket);
         }
 
-        public CellArrayElementAccessExpressionSyntaxNode CellArrayElementAccessExpressionSyntax(
+        public CellArrayElementAccessExpressionSyntaxNode CellArrayElementAccessExpressionSyntax(ExpressionSyntaxNode expression, SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace)
-            ExpressionSyntaxNode expression, 
-            SyntaxToken openingBrace, 
-            SyntaxList nodes, 
-            SyntaxToken closingBrace)
         {
-            return new CellArrayElementAccessExpressionSyntaxNode(
+            return new CellArrayElementAccessExpressionSyntaxNode(expression, openingBrace, nodes, closingBrace);
-                expression, 
-                openingBrace, 
-                nodes, 
-                closingBrace);
         }
 
-        public FunctionCallExpressionSyntaxNode FunctionCallExpressionSyntax(
+        public FunctionCallExpressionSyntaxNode FunctionCallExpressionSyntax(ExpressionSyntaxNode functionName, SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket)
-            ExpressionSyntaxNode functionName, 
-            SyntaxToken openingBracket, 
-            SyntaxList nodes, 
-            SyntaxToken closingBracket)
         {
-            return new FunctionCallExpressionSyntaxNode(
+            return new FunctionCallExpressionSyntaxNode(functionName, openingBracket, nodes, closingBracket);
-                functionName, 
-                openingBracket, 
-                nodes, 
-                closingBracket);
         }
 
-        public MemberAccessSyntaxNode MemberAccessSyntax(
+        public MemberAccessSyntaxNode MemberAccessSyntax(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand)
-            SyntaxNode leftOperand, 
-            SyntaxToken dot, 
-            SyntaxNode rightOperand)
         {
-            return new MemberAccessSyntaxNode(
+            return new MemberAccessSyntaxNode(leftOperand, dot, rightOperand);
-                leftOperand, 
-                dot, 
-                rightOperand);
         }
 
-        public UnaryPostixOperationExpressionSyntaxNode UnaryPostixOperationExpressionSyntax(
+        public UnaryPostixOperationExpressionSyntaxNode UnaryPostixOperationExpressionSyntax(ExpressionSyntaxNode operand, SyntaxToken operation)
-            ExpressionSyntaxNode operand, 
-            SyntaxToken operation)
         {
-            return new UnaryPostixOperationExpressionSyntaxNode(
+            return new UnaryPostixOperationExpressionSyntaxNode(operand, operation);
-                operand, 
-                operation);
         }
 
-        public IndirectMemberAccessSyntaxNode IndirectMemberAccessSyntax(
+        public IndirectMemberAccessSyntaxNode IndirectMemberAccessSyntax(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket)
-            SyntaxToken openingBracket, 
-            ExpressionSyntaxNode expression, 
-            SyntaxToken closingBracket)
         {
-            return new IndirectMemberAccessSyntaxNode(
+            return new IndirectMemberAccessSyntaxNode(openingBracket, expression, closingBracket);
-                openingBracket, 
-                expression, 
-                closingBracket);
         }
 
-        public CommandExpressionSyntaxNode CommandExpressionSyntax(
+        public CommandExpressionSyntaxNode CommandExpressionSyntax(IdentifierNameSyntaxNode commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments)
-            IdentifierNameSyntaxNode commandName, 
-            SyntaxList<UnquotedStringLiteralSyntaxNode> arguments)
         {
-            return new CommandExpressionSyntaxNode(
+            return new CommandExpressionSyntaxNode(commandName, arguments);
-                commandName, 
-                arguments);
         }
 
-        public BaseClassInvokationSyntaxNode BaseClassInvokationSyntax(
+        public BaseClassInvokationSyntaxNode BaseClassInvokationSyntax(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments)
-            ExpressionSyntaxNode methodName, 
-            SyntaxToken atSign, 
-            ExpressionSyntaxNode baseClassNameAndArguments)
         {
-            return new BaseClassInvokationSyntaxNode(
+            return new BaseClassInvokationSyntaxNode(methodName, atSign, baseClassNameAndArguments);
-                methodName, 
-                atSign, 
-                baseClassNameAndArguments);
         }
 
-        public AttributeAssignmentSyntaxNode AttributeAssignmentSyntax(
+        public AttributeAssignmentSyntaxNode AttributeAssignmentSyntax(SyntaxToken assignmentSign, ExpressionSyntaxNode value)
-            SyntaxToken assignmentSign, 
-            ExpressionSyntaxNode value)
         {
-            return new AttributeAssignmentSyntaxNode(
+            return new AttributeAssignmentSyntaxNode(assignmentSign, value);
-                assignmentSign, 
-                value);
         }
 
-        public AttributeSyntaxNode AttributeSyntax(
+        public AttributeSyntaxNode AttributeSyntax(IdentifierNameSyntaxNode name, AttributeAssignmentSyntaxNode? assignment)
-            IdentifierNameSyntaxNode name, 
-            AttributeAssignmentSyntaxNode? assignment)
         {
-            return new AttributeSyntaxNode(
+            return new AttributeSyntaxNode(name, assignment);
-                name, 
-                assignment);
         }
 
-        public AttributeListSyntaxNode AttributeListSyntax(
+        public AttributeListSyntaxNode AttributeListSyntax(SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket)
-            SyntaxToken openingBracket, 
-            SyntaxList nodes, 
-            SyntaxToken closingBracket)
         {
-            return new AttributeListSyntaxNode(
+            return new AttributeListSyntaxNode(openingBracket, nodes, closingBracket);
-                openingBracket, 
-                nodes, 
-                closingBracket);
         }
 
-        public MethodDefinitionSyntaxNode MethodDefinitionSyntax(
+        public MethodDefinitionSyntaxNode MethodDefinitionSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword)
-            SyntaxToken functionKeyword, 
-            FunctionOutputDescriptionSyntaxNode? outputDescription, 
-            CompoundNameSyntaxNode name, 
-            FunctionInputDescriptionSyntaxNode? inputDescription, 
-            SyntaxList<SyntaxToken> commas, 
-            SyntaxList body, 
-            EndKeywordSyntaxNode? endKeyword)
         {
-            return new MethodDefinitionSyntaxNode(
+            return new MethodDefinitionSyntaxNode(functionKeyword, outputDescription, name, inputDescription, commas, body, endKeyword);
-                functionKeyword, 
-                outputDescription, 
-                name, 
-                inputDescription, 
-                commas, 
-                body, 
-                endKeyword);
         }
 
-        public AbstractMethodDeclarationSyntaxNode AbstractMethodDeclarationSyntax(
+        public AbstractMethodDeclarationSyntaxNode AbstractMethodDeclarationSyntax(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription)
-            FunctionOutputDescriptionSyntaxNode? outputDescription, 
-            CompoundNameSyntaxNode name, 
-            FunctionInputDescriptionSyntaxNode? inputDescription)
         {
-            return new AbstractMethodDeclarationSyntaxNode(
+            return new AbstractMethodDeclarationSyntaxNode(outputDescription, name, inputDescription);
-                outputDescription, 
-                name, 
-                inputDescription);
         }
 
-        public MethodsListSyntaxNode MethodsListSyntax(
+        public MethodsListSyntaxNode MethodsListSyntax(SyntaxToken methodsKeyword, AttributeListSyntaxNode? attributes, SyntaxList methods, SyntaxToken endKeyword)
-            SyntaxToken methodsKeyword, 
-            AttributeListSyntaxNode? attributes, 
-            SyntaxList methods, 
-            SyntaxToken endKeyword)
         {
-            return new MethodsListSyntaxNode(
+            return new MethodsListSyntaxNode(methodsKeyword, attributes, methods, endKeyword);
-                methodsKeyword, 
-                attributes, 
-                methods, 
-                endKeyword);
         }
 
-        public PropertiesListSyntaxNode PropertiesListSyntax(
+        public PropertiesListSyntaxNode PropertiesListSyntax(SyntaxToken propertiesKeyword, AttributeListSyntaxNode? attributes, SyntaxList properties, SyntaxToken endKeyword)
-            SyntaxToken propertiesKeyword, 
-            AttributeListSyntaxNode? attributes, 
-            SyntaxList properties, 
-            SyntaxToken endKeyword)
         {
-            return new PropertiesListSyntaxNode(
+            return new PropertiesListSyntaxNode(propertiesKeyword, attributes, properties, endKeyword);
-                propertiesKeyword, 
-                attributes, 
-                properties, 
-                endKeyword);
         }
 
-        public BaseClassListSyntaxNode BaseClassListSyntax(
+        public BaseClassListSyntaxNode BaseClassListSyntax(SyntaxToken lessSign, SyntaxList baseClasses)
-            SyntaxToken lessSign, 
-            SyntaxList baseClasses)
         {
-            return new BaseClassListSyntaxNode(
+            return new BaseClassListSyntaxNode(lessSign, baseClasses);
-                lessSign, 
-                baseClasses);
         }
 
-        public ClassDeclarationSyntaxNode ClassDeclarationSyntax(
+        public ClassDeclarationSyntaxNode ClassDeclarationSyntax(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword)
-            SyntaxToken classdefKeyword, 
-            AttributeListSyntaxNode? attributes, 
-            IdentifierNameSyntaxNode className, 
-            BaseClassListSyntaxNode? baseClassList, 
-            SyntaxList nodes, 
-            SyntaxToken endKeyword)
         {
-            return new ClassDeclarationSyntaxNode(
+            return new ClassDeclarationSyntaxNode(classdefKeyword, attributes, className, baseClassList, nodes, endKeyword);
-                classdefKeyword, 
-                attributes, 
-                className, 
-                baseClassList, 
-                nodes, 
-                endKeyword);
         }
 
-        public EnumerationItemValueSyntaxNode EnumerationItemValueSyntax(
+        public EnumerationItemValueSyntaxNode EnumerationItemValueSyntax(SyntaxToken openingBracket, SyntaxList values, SyntaxToken closingBracket)
-            SyntaxToken openingBracket, 
-            SyntaxList values, 
-            SyntaxToken closingBracket)
         {
-            return new EnumerationItemValueSyntaxNode(
+            return new EnumerationItemValueSyntaxNode(openingBracket, values, closingBracket);
-                openingBracket, 
-                values, 
-                closingBracket);
         }
 
-        public EnumerationItemSyntaxNode EnumerationItemSyntax(
+        public EnumerationItemSyntaxNode EnumerationItemSyntax(IdentifierNameSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList<SyntaxToken> commas)
-            IdentifierNameSyntaxNode name, 
-            EnumerationItemValueSyntaxNode? values, 
-            SyntaxList<SyntaxToken> commas)
         {
-            return new EnumerationItemSyntaxNode(
+            return new EnumerationItemSyntaxNode(name, values, commas);
-                name, 
-                values, 
-                commas);
         }
 
-        public EnumerationListSyntaxNode EnumerationListSyntax(
+        public EnumerationListSyntaxNode EnumerationListSyntax(SyntaxToken enumerationKeyword, AttributeListSyntaxNode? attributes, SyntaxList<EnumerationItemSyntaxNode> items, SyntaxToken endKeyword)
-            SyntaxToken enumerationKeyword, 
-            AttributeListSyntaxNode? attributes, 
-            SyntaxList<EnumerationItemSyntaxNode> items, 
-            SyntaxToken endKeyword)
         {
-            return new EnumerationListSyntaxNode(
+            return new EnumerationListSyntaxNode(enumerationKeyword, attributes, items, endKeyword);
-                enumerationKeyword, 
-                attributes, 
-                items, 
-                endKeyword);
         }
 
-        public EventsListSyntaxNode EventsListSyntax(
+        public EventsListSyntaxNode EventsListSyntax(SyntaxToken eventsKeyword, AttributeListSyntaxNode? attributes, SyntaxList events, SyntaxToken endKeyword)
-            SyntaxToken eventsKeyword, 
-            AttributeListSyntaxNode? attributes, 
-            SyntaxList events, 
-            SyntaxToken endKeyword)
         {
-            return new EventsListSyntaxNode(
+            return new EventsListSyntaxNode(eventsKeyword, attributes, events, endKeyword);
-                eventsKeyword, 
-                attributes, 
-                events, 
-                endKeyword);
         }
 
-        public EndKeywordSyntaxNode EndKeywordSyntax(
+        public EndKeywordSyntaxNode EndKeywordSyntax(SyntaxToken endKeyword)
-            SyntaxToken endKeyword)
         {
-            return new EndKeywordSyntaxNode(
+            return new EndKeywordSyntaxNode(endKeyword);
-                endKeyword);
         }
     }
 }

Parser/SyntaxVisitor.Generated.cs

@@ -258,4 +258,4 @@ namespace Parser
             DefaultVisit(node);
         }
     }
-};
+}

SyntaxGenerator/DtoExtensions.cs

@@ -0,0 +1,10 @@
+namespace SyntaxGenerator
+{
+    public static class DtoExtensions
+    {
+        public static string GetPrivateFieldName(this FieldDescription field)
+        {
+            return "_" + field.FieldName;
+        }
+    }
+}

SyntaxGenerator/FieldDescription.cs

@@ -0,0 +1,17 @@
+using System.Xml.Serialization;
+
+namespace SyntaxGenerator
+{
+
+    public class FieldDescription
+    {
+        [XmlAttribute("Type")]
+        public string FieldType { get; set; }
+
+        [XmlAttribute("Name")]
+        public string FieldName { get; set; }
+
+        [XmlAttribute("Nullable")]
+        public bool FieldIsNullable { get; set; }
+    }
+}

SyntaxGenerator/SyntaxDescription.cs

@@ -0,0 +1,11 @@
+using System.Xml.Serialization;
+
+namespace SyntaxGenerator
+{
+    [XmlRoot(ElementName = "Syntax")]
+    public class SyntaxDescription
+    {
+        [XmlElement(ElementName = "Class")]
+        public SyntaxNodeDescription[] Nodes { get; set; }
+    }
+}

SyntaxGenerator/SyntaxExtensions.cs

@@ -0,0 +1,63 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Collections.Generic;
+using System.Linq;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace SyntaxGenerator
+{
+    public static class SyntaxExtensions
+    {
+        public static ArgumentListSyntax SingleArgument(ExpressionSyntax expression)
+        {
+            return
+                ArgumentList(
+                    SingletonSeparatedList(
+                        Argument(expression)));
+        }
+
+        public static ArgumentListSyntax SeveralArguments(IEnumerable<ExpressionSyntax> expressions)
+        {
+            return ArgumentList(
+                IntersperseWithCommas(
+                    expressions.Select(e => Argument(e))));
+        }
+
+        public static ArgumentListSyntax SeveralArguments(params ExpressionSyntax[] expressions)
+        {
+            return SeveralArguments((IEnumerable<ExpressionSyntax>)expressions);
+        }
+
+        public static IEnumerable<SyntaxNodeOrToken> IntersperseWithCommas(IEnumerable<SyntaxNodeOrToken> tokens)
+        {
+            var first = true;
+            foreach (var token in tokens)
+            {
+                if (first)
+                {
+                    yield return token;
+                    first = false;
+                }
+                else
+                {
+                    yield return Token(SyntaxKind.CommaToken);
+                    yield return token;
+                }
+            }
+        }
+
+        public static SeparatedSyntaxList<TNode> IntersperseWithCommas<TNode>(IEnumerable<TNode> tokens)
+            where TNode : SyntaxNode
+        {
+            return SeparatedList<TNode>(
+                IntersperseWithCommas(tokens.Select(token => (SyntaxNodeOrToken)token)));
+        }
+
+        public static SeparatedSyntaxList<TNode> IntersperseWithCommas<TNode>(params TNode[] tokens)
+            where TNode : SyntaxNode
+        {
+            return IntersperseWithCommas((IEnumerable<TNode>)tokens);
+        }
+    }
+}

SyntaxGenerator/SyntaxGenerator.csproj

@@ -3,6 +3,9 @@
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp3.0</TargetFramework>
   </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.7.0-3.final" />
+  </ItemGroup>
   <ItemGroup>
     <None Update="input.xml">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>

SyntaxGenerator/SyntaxNodeDescription.cs

@@ -2,19 +2,14 @@
 
 namespace SyntaxGenerator
 {
-    [XmlRoot(ElementName = "Syntax")]
-    public class SyntaxDescription
-    {
-        [XmlElement(ElementName = "Class")]
-        public SyntaxNodeDescription[] Nodes { get; set; }
-    }
-    
     public class SyntaxNodeDescription
     {
         [XmlAttribute("Name")]
         public string ClassName { get; set; }
+
         [XmlAttribute("BaseClass")]
         public string BaseClassName { get; set; }
+
         [XmlAttribute("Kind")]
         public string TokenKindName { get; set; }
 
@@ -27,14 +22,4 @@ namespace SyntaxGenerator
         
         private FieldDescription[] _fields = new FieldDescription[0];
     }
-    
-    public class FieldDescription
-    {
-        [XmlAttribute("Type")]
-        public string FieldType { get; set; }
-        [XmlAttribute("Name")]
-        public string FieldName { get; set; }
-        [XmlAttribute("Nullable")]
-        public bool FieldIsNullable { get; set; }
-    }
 }