protected static StatementSyntax CreateMarshalStructStatement()

in SharpGen/Generator/Marshallers/MarshallerBase.cs [114:175]
54 lines of code
6 McCabe index (conditional complexity)

        protected static StatementSyntax CreateMarshalStructStatement(
            CsMarshalBase marshallable,
            StructMarshalMethod marshalMethod,
            ExpressionSyntax publicElementExpr,
            ExpressionSyntax marshalElementExpr)
        {
            StatementSyntaxList statements = new();

            var marshalArgument = Argument(marshalElementExpr).WithRefOrOutKeyword(Token(SyntaxKind.RefKeyword));

            if (marshallable.PublicType is CsStruct {GenerateAsClass: true} structType &&
                marshalMethod == StructMarshalMethod.From)
            {
                var constructor = ObjectCreationExpression(ParseTypeName(structType.QualifiedName));
                var argumentList = !structType.HasCustomMarshal
                                       ? ArgumentList(SingletonSeparatedList(marshalArgument))
                                       : ArgumentList();

                statements.Add(
                    ExpressionStatement(
                        AssignmentExpression(
                            SyntaxKind.SimpleAssignmentExpression,
                            publicElementExpr, constructor.WithArgumentList(argumentList)
                        )
                    )
                );

                if (!structType.HasCustomMarshal)
                    return statements.ToStatement();
            }

            var methodName = IdentifierName($"__Marshal{marshalMethod}");

            var invocationExpression = marshallable.IsStaticMarshal
                                           ? InvocationExpression(
                                               MemberAccessExpression(
                                                   SyntaxKind.SimpleMemberAccessExpression,
                                                   ParseTypeName(marshallable.PublicType.QualifiedName), methodName
                                               ),
                                               ArgumentList(
                                                   SeparatedList(
                                                       new[]
                                                       {
                                                           Argument(publicElementExpr)
                                                              .WithRefOrOutKeyword(Token(SyntaxKind.RefKeyword)),
                                                           marshalArgument
                                                       }
                                                   )
                                               )
                                           )
                                           : InvocationExpression(
                                               MemberAccessExpression(
                                                   SyntaxKind.SimpleMemberAccessExpression,
                                                   publicElementExpr, methodName
                                               ),
                                               ArgumentList(SingletonSeparatedList(marshalArgument))
                                           );

            statements.Add(GenerateNullCheckIfNeeded(marshallable, ExpressionStatement(invocationExpression)));

            return statements.ToStatement();
        }