feat: improve constructor mapping readability

src/Riok.Mapperly/Descriptors/Constructors/InstanceConstructor.cs

@@ -1,7 +1,6 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Riok.Mapperly.Descriptors.Mappings;
-using Riok.Mapperly.Emit.Syntax;
 
 namespace Riok.Mapperly.Descriptors.Constructors;
 
@@ -13,5 +12,5 @@ public ExpressionSyntax CreateInstance(
         TypeMappingBuildContext ctx,
         IEnumerable<ArgumentSyntax> args,
         InitializerExpressionSyntax? initializer = null
-    ) => SyntaxFactoryHelper.CreateInstance(type, args).WithInitializer(initializer);
+    ) => ctx.SyntaxFactory.CreateInstance(type, args).WithInitializer(initializer);
 }

src/Riok.Mapperly/Descriptors/Enumerables/EnsureCapacity/EnsureCapacityInfo.cs

@@ -24,6 +24,6 @@ protected static ExpressionStatementSyntax EnsureCapacityStatement(
             sum = Add(sourceCount, targetCount);
         }
 
-        return syntaxFactory.ExpressionStatement(Invocation(MemberAccess(target, EnsureCapacityName), sum));
+        return syntaxFactory.ExpressionStatement(syntaxFactory.Invocation(MemberAccess(target, EnsureCapacityName), sum));
     }
 }

src/Riok.Mapperly/Descriptors/Enumerables/EnsureCapacity/EnsureCapacityNonEnumerated.cs

@@ -31,7 +31,7 @@ public override StatementSyntax Build(TypeMappingBuildContext ctx, ExpressionSyn
         var enumerableArgument = Argument(ctx.Source);
         var outVarArgument = OutVarArgument(sourceCountName);
 
-        var getNonEnumeratedInvocation = StaticInvocation(getNonEnumeratedMethod, enumerableArgument, outVarArgument);
+        var getNonEnumeratedInvocation = ctx.SyntaxFactory.StaticInvocation(getNonEnumeratedMethod, enumerableArgument, outVarArgument);
         var ensureCapacity = EnsureCapacityStatement(
             ctx.SyntaxFactory.AddIndentation(),
             target,

src/Riok.Mapperly/Descriptors/Mappings/DerivedExistingTargetTypeSwitchMapping.cs

@@ -66,8 +66,8 @@ private SwitchSectionSyntax BuildDefaultSwitchSection(TypeMappingBuildContext ct
         var defaultCaseLabel = DefaultSwitchLabel().AddLeadingLineFeed(sectionCtx.Indentation);
 
         // throw new ArgumentException(msg, nameof(ctx.Source)),
-        var sourceTypeExpr = Invocation(MemberAccess(ctx.Source, GetTypeMethodName));
-        var targetTypeExpr = Invocation(MemberAccess(target, GetTypeMethodName));
+        var sourceTypeExpr = ctx.SyntaxFactory.Invocation(MemberAccess(ctx.Source, GetTypeMethodName));
+        var targetTypeExpr = ctx.SyntaxFactory.Invocation(MemberAccess(target, GetTypeMethodName));
         var statementContext = sectionCtx.AddIndentation();
         var throwExpression = ThrowArgumentExpression(
                 InterpolatedString($"Cannot map {sourceTypeExpr} to {targetTypeExpr} as there is no known derived type mapping"),

src/Riok.Mapperly/Descriptors/Mappings/DerivedTypeSwitchMapping.cs

@@ -18,7 +18,7 @@ public class DerivedTypeSwitchMapping(ITypeSymbol sourceType, ITypeSymbol target
     public override ExpressionSyntax Build(TypeMappingBuildContext ctx)
     {
         // _ => throw new ArgumentException(msg, nameof(ctx.Source)),
-        var sourceTypeExpr = Invocation(MemberAccess(ctx.Source, GetTypeMethodName));
+        var sourceTypeExpr = ctx.SyntaxFactory.Invocation(MemberAccess(ctx.Source, GetTypeMethodName));
         var fallbackArm = SwitchArm(
             DiscardPattern(),
             ThrowArgumentExpression(

src/Riok.Mapperly/Descriptors/Mappings/Enums/EnumFromStringParseMapping.cs

@@ -22,7 +22,7 @@ public override ExpressionSyntax Build(TypeMappingBuildContext ctx)
         // System.Enum.Parse<TargetType>(source, ignoreCase)
         if (genericParseMethodSupported)
         {
-            return GenericInvocation(
+            return ctx.SyntaxFactory.GenericInvocation(
                 EnumClassName,
                 ParseMethodName,
                 new[] { FullyQualifiedIdentifier(TargetType) },
@@ -32,7 +32,7 @@ public override ExpressionSyntax Build(TypeMappingBuildContext ctx)
         }
 
         // (TargetType)System.Enum.Parse(typeof(TargetType), source, ignoreCase)
-        var enumParseInvocation = Invocation(
+        var enumParseInvocation = ctx.SyntaxFactory.Invocation(
             MemberAccess(EnumClassName, ParseMethodName),
             TypeOfExpression(FullyQualifiedIdentifier(TargetType)),
             ctx.Source,

src/Riok.Mapperly/Descriptors/Mappings/Enums/EnumFromStringSwitchMapping.cs

@@ -52,7 +52,7 @@ private SwitchExpressionArmSyntax BuildArmIgnoreCase(string ignoreCaseSwitchDesi
 
         // when s.Equals(nameof(source.Value1), StringComparison.OrdinalIgnoreCase)
         var whenClause = SwitchWhen(
-            Invocation(
+            InvocationWithoutIndention(
                 MemberAccess(ignoreCaseSwitchDesignatedVariableName, StringEqualsMethodName),
                 NameOf(typeMemberAccess),
                 IdentifierName(StringComparisonFullName)

src/Riok.Mapperly/Descriptors/Mappings/Enums/EnumToStringMapping.cs

@@ -19,7 +19,7 @@ public class EnumToStringMapping(ITypeSymbol sourceType, ITypeSymbol targetType,
     public override IEnumerable<StatementSyntax> BuildBody(TypeMappingBuildContext ctx)
     {
         // fallback switch arm: _ => source.ToString()
-        var fallbackArm = SwitchArm(DiscardPattern(), Invocation(MemberAccess(ctx.Source, ToStringMethodName)));
+        var fallbackArm = SwitchArm(DiscardPattern(), ctx.SyntaxFactory.Invocation(MemberAccess(ctx.Source, ToStringMethodName)));
 
         // switch for each name to the enum value
         // eg: Enum1.Value1 => "Value1"

src/Riok.Mapperly/Descriptors/Mappings/ExistingTarget/ForEachAddEnumerableExistingTargetMapping.cs

@@ -38,7 +38,7 @@ public override IEnumerable<StatementSyntax> Build(TypeMappingBuildContext ctx,
         var (loopItemCtx, loopItemVariableName) = ctx.WithNewSource(LoopItemVariableName);
         var convertedSourceItemExpression = elementMapping.Build(loopItemCtx);
         var addMethod = MemberAccess(target, insertMethodName);
-        var body = Invocation(addMethod, convertedSourceItemExpression);
+        var body = ctx.SyntaxFactory.Invocation(addMethod, convertedSourceItemExpression);
         yield return ctx.SyntaxFactory.ForEach(loopItemVariableName, ctx.Source, body);
     }
 }

src/Riok.Mapperly/Descriptors/Mappings/LinqConstructorMapping.cs

@@ -24,13 +24,13 @@ public override ExpressionSyntax Build(TypeMappingBuildContext ctx)
             var (lambdaCtx, lambdaSourceName) = ctx.WithNewScopedSource();
             var sourceMapExpression = elementMapping.Build(lambdaCtx);
             var convertLambda = Lambda(lambdaSourceName, sourceMapExpression);
-            mappedSource = Invocation(selectMethod, ctx.Source, convertLambda);
+            mappedSource = ctx.SyntaxFactory.Invocation(selectMethod, ctx.Source, convertLambda);
         }
         else
         {
             mappedSource = elementMapping.Build(ctx);
         }
 
-        return CreateInstance(TargetType, mappedSource);
+        return ctx.SyntaxFactory.CreateInstance(TargetType, mappedSource);
     }
 }

src/Riok.Mapperly/Descriptors/Mappings/LinqDictionaryMapping.cs

@@ -23,7 +23,7 @@ public override ExpressionSyntax Build(TypeMappingBuildContext ctx)
         // if key and value types do not change then use a simple call
         // ie: source.ToImmutableDictionary();
         if (keyMapping.IsSynthetic && valueMapping.IsSynthetic)
-            return Invocation(collectMethod, ctx.Source);
+            return ctx.SyntaxFactory.Invocation(collectMethod, ctx.Source);
 
         // create expressions mapping the key and value and then create the final expression
         // ie: source.ToImmutableDictionary(x => x.Key, x => (int)x.Value);
@@ -35,6 +35,6 @@ public override ExpressionSyntax Build(TypeMappingBuildContext ctx)
         var valueMapExpression = valueMapping.Build(valueLambdaCtx);
         var valueExpression = Lambda(valueLambdaParamName, valueMapExpression);
 
-        return Invocation(collectMethod, ctx.Source, keyExpression, valueExpression);
+        return ctx.SyntaxFactory.Invocation(collectMethod, ctx.Source, keyExpression, valueExpression);
     }
 }

src/Riok.Mapperly/Descriptors/Mappings/LinqEnumerableMapping.cs

@@ -25,13 +25,13 @@ public override ExpressionSyntax Build(TypeMappingBuildContext ctx)
             var (lambdaCtx, lambdaSourceName) = ctx.WithNewScopedSource();
             var sourceMapExpression = elementMapping.Build(lambdaCtx);
             var convertLambda = Lambda(lambdaSourceName, sourceMapExpression);
-            mappedSource = Invocation(selectMethod, ctx.Source, convertLambda);
+            mappedSource = ctx.SyntaxFactory.Invocation(selectMethod, ctx.Source, convertLambda);
         }
         else
         {
             mappedSource = elementMapping.Build(ctx);
         }
 
-        return collectMethod == null ? mappedSource : Invocation(collectMethod, mappedSource);
+        return collectMethod == null ? mappedSource : ctx.SyntaxFactory.Invocation(collectMethod, mappedSource);
     }
 }

src/Riok.Mapperly/Descriptors/Mappings/MemberMappings/MemberNullDelegateAssignmentMapping.cs

@@ -74,7 +74,7 @@ public override bool Equals(object? obj)
                 nullConditional: false,
                 skipTrailingNonNullable: true
             );
-            return new[] { ctx.SyntaxFactory.ExpressionStatement(ThrowArgumentNullException(nameofSourceAccess)) };
+            return [ctx.SyntaxFactory.ExpressionStatement(ThrowArgumentNullException(nameofSourceAccess))];
         }
 
         // target.A = null;

src/Riok.Mapperly/Descriptors/Mappings/MemberMappings/SourceValue/MethodProvidedSourceValue.cs

@@ -1,5 +1,4 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using static Riok.Mapperly.Emit.Syntax.SyntaxFactoryHelper;
 
 namespace Riok.Mapperly.Descriptors.Mappings.MemberMappings.SourceValue;
 
@@ -8,5 +7,5 @@ namespace Riok.Mapperly.Descriptors.Mappings.MemberMappings.SourceValue;
 /// </summary>
 public class MethodProvidedSourceValue(string methodName) : ISourceValue
 {
-    public ExpressionSyntax Build(TypeMappingBuildContext ctx) => Invocation(methodName);
+    public ExpressionSyntax Build(TypeMappingBuildContext ctx) => ctx.SyntaxFactory.Invocation(methodName);
 }

src/Riok.Mapperly/Descriptors/Mappings/MethodMapping.cs

@@ -79,7 +79,11 @@ ITypeSymbol targetType
     public bool IsSynthetic => false;
 
     public virtual ExpressionSyntax Build(TypeMappingBuildContext ctx) =>
-        Invocation(MethodName, SourceParameter.WithArgument(ctx.Source), ReferenceHandlerParameter?.WithArgument(ctx.ReferenceHandler));
+        ctx.SyntaxFactory.Invocation(
+            MethodName,
+            SourceParameter.WithArgument(ctx.Source),
+            ReferenceHandlerParameter?.WithArgument(ctx.ReferenceHandler)
+        );
 
     public virtual MethodDeclarationSyntax BuildMethod(SourceEmitterContext ctx)
     {

src/Riok.Mapperly/Descriptors/Mappings/NewValueTupleConstructorMapping.cs

@@ -24,6 +24,6 @@ public override ExpressionSyntax Build(TypeMappingBuildContext ctx)
         // new ValueTuple<T..>(ctorArgs)
         var ctorArgs = _constructorPropertyMappings.Select(x => x.BuildArgument(ctx, emitFieldName: false));
         var typeArguments = TypeArgumentList(((INamedTypeSymbol)TargetType).TypeArguments.Select(NonNullableIdentifier));
-        return CreateGenericInstance(ValueTupleName, typeArguments, ctorArgs);
+        return ctx.SyntaxFactory.CreateGenericInstance(ValueTupleName, typeArguments, ctorArgs);
     }
 }

src/Riok.Mapperly/Descriptors/Mappings/QueryableProjectionMapping.cs

@@ -25,13 +25,11 @@ public override IEnumerable<StatementSyntax> BuildBody(TypeMappingBuildContext c
 
         var delegateMappingSyntax = delegateMapping.Build(lambdaCtx);
         var projectionLambda = Lambda(lambdaSourceName, delegateMappingSyntax);
-        var select = StaticInvocation(QueryableReceiverName, SelectMethodName, ctx.Source, projectionLambda);
+        var select = ctx.SyntaxFactory.StaticInvocation(QueryableReceiverName, SelectMethodName, ctx.Source, projectionLambda);
         var returnStatement = ctx.SyntaxFactory.Return(select);
-        return new[]
-        {
-            returnStatement
-                .WithLeadingTrivia(returnStatement.GetLeadingTrivia().Insert(0, ElasticCarriageReturnLineFeed).Insert(1, Nullable(false)))
-                .WithTrailingTrivia(returnStatement.GetTrailingTrivia().Insert(0, ElasticCarriageReturnLineFeed).Insert(1, Nullable(true)))
-        };
+        var leadingTrivia = returnStatement.GetLeadingTrivia().Insert(0, ElasticCarriageReturnLineFeed).Insert(1, Nullable(false));
+        var trailingTrivia = returnStatement.GetTrailingTrivia().Insert(0, ElasticCarriageReturnLineFeed).Insert(1, Nullable(true));
+        returnStatement = returnStatement.WithLeadingTrivia(leadingTrivia).WithTrailingTrivia(trailingTrivia);
+        return [returnStatement];
     }
 }

src/Riok.Mapperly/Descriptors/Mappings/SourceObjectMethodMapping.cs

@@ -22,7 +22,10 @@ public class SourceObjectMethodMapping(
 {
     public override ExpressionSyntax Build(TypeMappingBuildContext ctx)
     {
-        var sourceExpression = Invocation(MemberAccess(ctx.Source, methodName), BuildArguments(ctx).WhereNotNull().ToArray());
+        var sourceExpression = ctx.SyntaxFactory.Invocation(
+            MemberAccess(ctx.Source, methodName),
+            BuildArguments(ctx).WhereNotNull().ToArray()
+        );
         return delegateMapping == null ? sourceExpression : delegateMapping.Build(ctx.WithSource(sourceExpression));
     }
 

src/Riok.Mapperly/Descriptors/Mappings/StaticMethodMapping.cs

@@ -1,6 +1,5 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using static Riok.Mapperly.Emit.Syntax.SyntaxFactoryHelper;
 
 namespace Riok.Mapperly.Descriptors.Mappings;
 
@@ -9,5 +8,5 @@ namespace Riok.Mapperly.Descriptors.Mappings;
 /// </summary>
 public class StaticMethodMapping(IMethodSymbol method) : NewInstanceMapping(method.Parameters.Single().Type, method.ReturnType)
 {
-    public override ExpressionSyntax Build(TypeMappingBuildContext ctx) => StaticInvocation(method, ctx.Source);
+    public override ExpressionSyntax Build(TypeMappingBuildContext ctx) => ctx.SyntaxFactory.StaticInvocation(method, ctx.Source);
 }

src/Riok.Mapperly/Descriptors/Mappings/UserMappings/UserDefinedExistingTargetMethodMapping.cs

@@ -44,7 +44,7 @@ public override ExpressionSyntax Build(TypeMappingBuildContext ctx) =>
     public IEnumerable<StatementSyntax> Build(TypeMappingBuildContext ctx, ExpressionSyntax target)
     {
         return ctx.SyntaxFactory.SingleStatement(
-            Invocation(
+            ctx.SyntaxFactory.Invocation(
                 MethodName,
                 SourceParameter.WithArgument(ctx.Source),
                 TargetParameter.WithArgument(target),

src/Riok.Mapperly/Descriptors/Mappings/UserMappings/UserDefinedNewInstanceRuntimeTargetTypeMapping.cs

@@ -63,7 +63,7 @@ public override IEnumerable<StatementSyntax> BuildBody(TypeMappingBuildContext c
         var targetTypeExpr = BuildTargetType();
 
         // _ => throw new ArgumentException(msg, nameof(ctx.Source)),
-        var sourceType = Invocation(MemberAccess(ctx.Source, GetTypeMethodName));
+        var sourceType = ctx.SyntaxFactory.Invocation(MemberAccess(ctx.Source, GetTypeMethodName));
         var fallbackArm = SwitchArm(
             DiscardPattern(),
             ThrowArgumentExpression(
@@ -92,7 +92,7 @@ public override IEnumerable<StatementSyntax> BuildBody(TypeMappingBuildContext c
     protected virtual ExpressionSyntax? BuildSwitchArmWhenClause(ExpressionSyntax runtimeTargetType, RuntimeTargetTypeMapping mapping)
     {
         // targetType.IsAssignableFrom(typeof(ADto))
-        return Invocation(
+        return InvocationWithoutIndention(
             MemberAccess(runtimeTargetType, IsAssignableFromMethodName),
             TypeOfExpression(FullyQualifiedIdentifier(mapping.Mapping.TargetType.NonNullable()))
         );

src/Riok.Mapperly/Descriptors/Mappings/UserMappings/UserImplementedExistingTargetMethodMapping.cs

@@ -33,7 +33,7 @@ public override IEnumerable<StatementSyntax> Build(TypeMappingBuildContext ctx,
         if (Method.ReceiverType?.TypeKind != TypeKind.Interface)
         {
             yield return ctx.SyntaxFactory.ExpressionStatement(
-                Invocation(
+                ctx.SyntaxFactory.Invocation(
                     receiver == null ? IdentifierName(Method.Name) : MemberAccess(receiver, Method.Name),
                     sourceParameter.WithArgument(ctx.Source),
                     targetParameter.WithArgument(target),
@@ -49,7 +49,7 @@ public override IEnumerable<StatementSyntax> Build(TypeMappingBuildContext ctx,
         );
         var methodExpr = MemberAccess(ParenthesizedExpression(castedThis), Method.Name);
         yield return ctx.SyntaxFactory.ExpressionStatement(
-            Invocation(
+            ctx.SyntaxFactory.Invocation(
                 methodExpr,
                 sourceParameter.WithArgument(ctx.Source),
                 targetParameter.WithArgument(target),

src/Riok.Mapperly/Descriptors/Mappings/UserMappings/UserImplementedMethodMapping.cs

@@ -29,7 +29,7 @@ public override ExpressionSyntax Build(TypeMappingBuildContext ctx)
         // if the user implemented method is on an interface,
         // we explicitly cast to be able to use the default interface implementation or explicit implementations
         if (Method.ReceiverType?.TypeKind != TypeKind.Interface)
-            return Invocation(
+            return ctx.SyntaxFactory.Invocation(
                 receiver == null ? IdentifierName(Method.Name) : MemberAccess(receiver, Method.Name),
                 sourceParameter.WithArgument(ctx.Source),
                 referenceHandlerParameter?.WithArgument(ctx.ReferenceHandler)
@@ -40,7 +40,7 @@ public override ExpressionSyntax Build(TypeMappingBuildContext ctx)
             receiver == null ? ThisExpression() : IdentifierName(receiver)
         );
         var methodExpr = MemberAccess(ParenthesizedExpression(castedReceiver), Method.Name);
-        return Invocation(
+        return ctx.SyntaxFactory.Invocation(
             methodExpr,
             sourceParameter.WithArgument(ctx.Source),
             referenceHandlerParameter?.WithArgument(ctx.ReferenceHandler)

src/Riok.Mapperly/Descriptors/ObjectFactories/GenericSourceObjectFactory.cs

@@ -18,5 +18,5 @@ public override bool CanCreateInstanceOfType(ITypeSymbol sourceType, ITypeSymbol
         && typeChecker.CheckTypes((Method.TypeParameters[0], sourceType));
 
     protected override ExpressionSyntax BuildCreateType(ITypeSymbol sourceType, ITypeSymbol targetTypeToCreate, ExpressionSyntax source) =>
-        GenericInvocation(Method.Name, [NonNullableIdentifier(sourceType)], source);
+        GenericInvocationWithoutIndention(Method.Name, [NonNullableIdentifier(sourceType)], source);
 }

src/Riok.Mapperly/Descriptors/ObjectFactories/GenericSourceTargetObjectFactory.cs

@@ -25,6 +25,6 @@ protected override ExpressionSyntax BuildCreateType(ITypeSymbol sourceType, ITyp
         var typeParams = new TypeSyntax[2];
         typeParams[sourceTypeParameterIndex] = NonNullableIdentifier(sourceType);
         typeParams[_targetTypeParameterIndex] = NonNullableIdentifier(targetTypeToCreate);
-        return GenericInvocation(Method.Name, typeParams, source);
+        return GenericInvocationWithoutIndention(Method.Name, typeParams, source);
     }
 }

src/Riok.Mapperly/Descriptors/ObjectFactories/GenericTargetObjectFactory.cs

@@ -17,5 +17,5 @@ public override bool CanCreateInstanceOfType(ITypeSymbol sourceType, ITypeSymbol
         typeChecker.CheckTypes((Method.TypeParameters[0], targetTypeToCreate));
 
     protected override ExpressionSyntax BuildCreateType(ITypeSymbol sourceType, ITypeSymbol targetTypeToCreate, ExpressionSyntax source) =>
-        GenericInvocation(Method.Name, new[] { NonNullableIdentifier(targetTypeToCreate) });
+        GenericInvocationWithoutIndention(Method.Name, [NonNullableIdentifier(targetTypeToCreate)]);
 }

src/Riok.Mapperly/Descriptors/ObjectFactories/GenericTargetObjectFactoryWithSource.cs

@@ -18,5 +18,5 @@ public override bool CanCreateInstanceOfType(ITypeSymbol sourceType, ITypeSymbol
         && SymbolEqualityComparer.Default.Equals(Method.Parameters[0].Type, sourceType);
 
     protected override ExpressionSyntax BuildCreateType(ITypeSymbol sourceType, ITypeSymbol targetTypeToCreate, ExpressionSyntax source) =>
-        GenericInvocation(Method.Name, new[] { NonNullableIdentifier(targetTypeToCreate) }, source);
+        GenericInvocationWithoutIndention(Method.Name, [NonNullableIdentifier(targetTypeToCreate)], source);
 }

src/Riok.Mapperly/Descriptors/ObjectFactories/SimpleObjectFactory.cs

@@ -14,5 +14,5 @@ public override bool CanCreateInstanceOfType(ITypeSymbol sourceType, ITypeSymbol
         SymbolEqualityComparer.Default.Equals(Method.ReturnType, targetTypeToCreate);
 
     protected override ExpressionSyntax BuildCreateType(ITypeSymbol sourceType, ITypeSymbol targetTypeToCreate, ExpressionSyntax source) =>
-        Invocation(Method.Name, Array.Empty<ExpressionSyntax>());
+        InvocationWithoutIndention(Method.Name);
 }

src/Riok.Mapperly/Descriptors/ObjectFactories/SimpleObjectFactoryWithSource.cs

@@ -17,5 +17,5 @@ public override bool CanCreateInstanceOfType(ITypeSymbol sourceType, ITypeSymbol
         && SymbolEqualityComparer.Default.Equals(sourceType, Method.Parameters[0].Type);
 
     protected override ExpressionSyntax BuildCreateType(ITypeSymbol sourceType, ITypeSymbol targetTypeToCreate, ExpressionSyntax source) =>
-        Invocation(Method.Name, source);
+        InvocationWithoutIndention(Method.Name, source);
 }

src/Riok.Mapperly/Descriptors/UnsafeAccess/UnsafeConstructorAccessor.cs

@@ -28,6 +28,6 @@ public ExpressionSyntax CreateInstance(
         InitializerExpressionSyntax? initializer = null
     )
     {
-        return StaticInvocation(className, methodName, args);
+        return ctx.SyntaxFactory.StaticInvocation(className, methodName, args);
     }
 }

src/Riok.Mapperly/Descriptors/UnsafeAccess/UnsafeFieldAccessor.cs

@@ -44,7 +44,7 @@ public ExpressionSyntax BuildAccess(ExpressionSyntax? baseAccess, bool nullCondi
             throw new ArgumentNullException(nameof(baseAccess));
 
         ExpressionSyntax method = nullConditional ? ConditionalAccess(baseAccess, methodName) : MemberAccess(baseAccess, methodName);
-        return Invocation(method);
+        return InvocationWithoutIndention(method);
     }
 
     public ExpressionSyntax BuildAssignment(ExpressionSyntax? baseAccess, ExpressionSyntax valueToAssign, bool coalesceAssignment = false)