public List <StatementSyntax> CreateStatements()
        {
            var args = CreateConstructorArgs()
                       .ToArray();

            var createExpression = ObjectCreationExpression
                                   (
                IdentifierName(SerializableTypeName)
                                   )
                                   .WithArgumentList
                                   (
                ArgumentList
                (
                    SeparatedList <ArgumentSyntax>
                    (
                        args
                    )
                )
                                   );

            if (BaseStatements.Any(bs => bs is ExpressionStatementSyntax))
            {
                createExpression = createExpression
                                   .WithInitializer(CreateObjectBaseInitializerList());
            }

            PreSerializationStatements.Add(EmitValueConstructionStatement(createExpression));

            return(PreSerializationStatements);
        }
        private IEnumerable <SyntaxNodeOrToken> CreateInitializerListSyntaxNodeOrTokens()
        {
            foreach (AssignmentExpressionSyntax statement in BaseStatements
                     .Where(s => s is ExpressionStatementSyntax)
                     .Reverse()
                     .Skip(1)
                     .Reverse()
                     .Cast <ExpressionStatementSyntax>()
                     .Select(es => (AssignmentExpressionSyntax)es.Expression))
            {
                string fieldName     = statement.Left.ToFullString().Split('.').Last();
                string tempLocalName = $"local_{fieldName}";

                CreateTempLocal(tempLocalName, statement);

                yield return(AssignmentExpression
                             (
                                 SyntaxKind.SimpleAssignmentExpression,
                                 IdentifierName(fieldName),
                                 IdentifierName(tempLocalName)
                             ));

                yield return(Token(SyntaxKind.CommaToken));
            }

            var last = BaseStatements
                       .Where(s => s is ExpressionStatementSyntax)
                       .Cast <ExpressionStatementSyntax>()
                       .Select(es => (AssignmentExpressionSyntax)es.Expression)
                       .Last();

            foreach (var syntaxNodeOrToken in YieldLast(last))
            {
                yield return(syntaxNodeOrToken);
            }
        }