feat: Respect .editorconfig end_of_line and charset in generated code

Generated mapper files (.g.cs) now honor .editorconfig settings:
- end_of_line: supports lf, crlf, cr (defaults to crlf)
- charset: supports utf-8, utf-8-bom, utf-16be, utf-16le (defaults to utf-8 without BOM)

This allows generated code to match the project's line ending and encoding
preferences, avoiding git diffs and post-processing requirements.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: YoelDruxman

docs/docs/configuration/generated-source.mdx

@@ -84,3 +84,38 @@ The code generated by Mapperly can be identified in several ways:
   > Note: the version `1.0.0.0` will be the version of the NuGet package of Mapperly that you are using.
 
 Using these identification points, you can configure most tooling to apply a different set of rules to the generated source.
+
+## EditorConfig support
+
+Mapperly respects `.editorconfig` settings for the generated source files:
+
+### Line endings (`end_of_line`)
+
+The generated code honors the `end_of_line` setting from your `.editorconfig`:
+
+```ini
+[*.cs]
+end_of_line = lf
+```
+
+Supported values:
+- `lf` - Unix-style line endings (`\n`)
+- `crlf` - Windows-style line endings (`\r\n`, default)
+- `cr` - Classic Mac-style line endings (`\r`)
+
+### Character encoding (`charset`)
+
+The generated code honors the `charset` setting from your `.editorconfig`:
+
+```ini
+[*.cs]
+charset = utf-8
+```
+
+Supported values:
+- `utf-8` - UTF-8 without BOM (default)
+- `utf-8-bom` - UTF-8 with BOM
+- `utf-16le` - UTF-16 Little Endian
+- `utf-16be` - UTF-16 Big Endian
+
+This ensures generated mapper files match your project's coding standards and avoids unnecessary git diffs due to line ending or encoding differences.

src/Riok.Mapperly/Helpers/IncrementalValuesProviderExtensions.cs

@@ -1,5 +1,6 @@
 using System.Text;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
 using Riok.Mapperly.Output;
 
 namespace Riok.Mapperly.Helpers;
@@ -62,6 +63,9 @@ IncrementalValuesProvider<ImmutableEquatableArray<Diagnostic>> diagnostics
         );
     }
 
+    // UTF-8 encoding without BOM (default for 'charset = utf-8' in .editorconfig)
+    private static readonly Encoding _utf8NoBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);
+
     /// <summary>
     /// Registers an implementation source output for the provided mappers.
     /// </summary>
@@ -76,7 +80,40 @@ IncrementalValuesProvider<MapperNode> mappers
             mappers,
             static (spc, mapper) =>
             {
-                var mapperText = mapper.Body.GetText(Encoding.UTF8);
+                // Respect .editorconfig charset setting
+                // Default to UTF-8 without BOM (most common for source files)
+                var encoding = _utf8NoBom;
+                if (!string.IsNullOrEmpty(mapper.Charset))
+                {
+                    encoding = mapper.Charset switch
+                    {
+                        "utf-8-bom" => Encoding.UTF8, // UTF-8 with BOM
+                        "utf-16be" => Encoding.BigEndianUnicode,
+                        "utf-16le" => Encoding.Unicode,
+                        _ => _utf8NoBom, // utf-8 and others default to no BOM
+                    };
+                }
+
+                var mapperText = mapper.Body.GetText(encoding);
+
+                // Respect .editorconfig end_of_line setting
+                // The syntax tree uses CRLF by default (ElasticCarriageReturnLineFeed)
+                if (!string.IsNullOrEmpty(mapper.EndOfLine) && !string.Equals(mapper.EndOfLine, "crlf", StringComparison.Ordinal))
+                {
+                    var newLine = mapper.EndOfLine switch
+                    {
+                        "lf" => "\n",
+                        "cr" => "\r",
+                        _ => null,
+                    };
+
+                    if (newLine != null)
+                    {
+                        var text = mapperText.ToString().Replace("\r\n", newLine);
+                        mapperText = SourceText.From(text, encoding);
+                    }
+                }
+
                 spc.AddSource(mapper.FileName, mapperText);
             }
         );

src/Riok.Mapperly/MapperGenerator.cs

@@ -1,6 +1,7 @@
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Riok.Mapperly.Abstractions;
 using Riok.Mapperly.Configuration;
 using Riok.Mapperly.Descriptors;
@@ -70,7 +71,11 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             .Combine(compilationContext)
             .Combine(mapperDefaults)
             .Combine(useStaticMappers)
-            .Select(static (x, ct) => BuildDescriptor(x.Left.Left.Right, x.Left.Left.Left, x.Left.Right, x.Right, ct))
+            .Combine(context.AnalyzerConfigOptionsProvider)
+            .Select(
+                static (x, ct) =>
+                    BuildDescriptor(x.Left.Left.Left.Right, x.Left.Left.Left.Left, x.Left.Left.Right, x.Left.Right, x.Right, ct)
+            )
             .WhereNotNull();
 
         // output the diagnostics
@@ -89,6 +94,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
         MapperDeclaration mapperDeclaration,
         MapperConfiguration mapperDefaults,
         ImmutableArray<UseStaticMapperConfiguration> assemblyScopedStaticMappers,
+        AnalyzerConfigOptionsProvider configOptionsProvider,
         CancellationToken cancellationToken
     )
     {
@@ -110,9 +116,18 @@ CancellationToken cancellationToken
                 assemblyScopedStaticMappers
             );
             var (descriptor, diagnostics) = builder.Build(cancellationToken);
+
+            // Get editorconfig settings from the mapper's source file
+            var syntaxTree = mapperDeclaration.Syntax.SyntaxTree;
+            var configOptions = configOptionsProvider.GetOptions(syntaxTree);
+            configOptions.TryGetValue("end_of_line", out var endOfLine);
+            configOptions.TryGetValue("charset", out var charset);
+
             var mapper = new MapperNode(
                 compilationContext.FileNameBuilder.Build(descriptor),
-                SourceEmitter.Build(descriptor, cancellationToken)
+                SourceEmitter.Build(descriptor, cancellationToken),
+                endOfLine,
+                charset
             );
             return new MapperAndDiagnostics(mapper, diagnostics.ToImmutableEquatableArray());
         }

src/Riok.Mapperly/Output/MapperNode.cs

@@ -2,12 +2,15 @@
 
 namespace Riok.Mapperly.Output;
 
-public readonly record struct MapperNode(string FileName, CompilationUnitSyntax Body)
+public readonly record struct MapperNode(string FileName, CompilationUnitSyntax Body, string? EndOfLine = null, string? Charset = null)
 {
     public bool Equals(MapperNode other)
     {
-        return string.Equals(FileName, other.FileName, StringComparison.Ordinal) && Body.IsEquivalentTo(other.Body);
+        return string.Equals(FileName, other.FileName, StringComparison.Ordinal)
+            && Body.IsEquivalentTo(other.Body)
+            && string.Equals(EndOfLine, other.EndOfLine, StringComparison.Ordinal)
+            && string.Equals(Charset, other.Charset, StringComparison.Ordinal);
     }
 
-    public override int GetHashCode() => HashCode.Combine(FileName, Body.SyntaxTree.Length);
+    public override int GetHashCode() => HashCode.Combine(FileName, Body.SyntaxTree.Length, EndOfLine, Charset);
 }

test/Riok.Mapperly.Tests/Generator/EndOfLineTest.cs

@@ -0,0 +1,95 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Riok.Mapperly.Tests.Generator;
+
+public class EndOfLineTest
+{
+    [Theory]
+    [InlineData(null, "\r\n")]
+    [InlineData("lf", "\n")]
+    [InlineData("crlf", "\r\n")]
+    [InlineData("cr", "\r")]
+    public void ShouldRespectEditorConfigEndOfLine(string? endOfLineSetting, string expectedLineEnding)
+    {
+        var generatedSource = GenerateSource(endOfLine: endOfLineSetting);
+
+        generatedSource.ShouldContain(expectedLineEnding);
+
+        // Verify other line endings are NOT present
+        if (expectedLineEnding != "\r\n")
+        {
+            generatedSource.ShouldNotContain("\r\n");
+        }
+
+        var withoutCrlf = generatedSource.Replace("\r\n", "");
+        if (expectedLineEnding != "\n")
+        {
+            withoutCrlf.ShouldNotContain("\n");
+        }
+
+        if (expectedLineEnding != "\r")
+        {
+            withoutCrlf.ShouldNotContain("\r");
+        }
+    }
+
+    [Theory]
+    [InlineData(null, false)]
+    [InlineData("utf-8", false)]
+    [InlineData("utf-8-bom", true)]
+    public void ShouldRespectEditorConfigCharset(string? charsetSetting, bool expectBom)
+    {
+        var generatedText = GenerateSourceText(charset: charsetSetting);
+        var preamble = generatedText.Encoding?.GetPreamble() ?? [];
+
+        preamble.Length.ShouldBe(expectBom ? 3 : 0, $"charset={charsetSetting ?? "(default)"} should {(expectBom ? "" : "not ")}have BOM");
+    }
+
+    private static string GenerateSource(string? endOfLine = null, string? charset = null) =>
+        GenerateSourceText(endOfLine, charset).ToString();
+
+    private static SourceText GenerateSourceText(string? endOfLine = null, string? charset = null)
+    {
+        var source = TestSourceBuilder.Mapping("string", "string");
+        var syntaxTree = CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default);
+        var compilation = TestHelper.BuildCompilation(syntaxTree);
+        var configOptionsProvider = new TestAnalyzerConfigOptionsProvider(endOfLine, charset);
+
+        GeneratorDriver driver = CSharpGeneratorDriver.Create(
+            [new MapperGenerator().AsSourceGenerator()],
+            optionsProvider: configOptionsProvider
+        );
+        driver = driver.RunGenerators(compilation);
+
+        return driver.GetRunResult().GeneratedTrees.First().GetText();
+    }
+
+    private class TestAnalyzerConfigOptionsProvider(string? endOfLine, string? charset) : AnalyzerConfigOptionsProvider
+    {
+        private readonly TestAnalyzerConfigOptions _fileOptions = new(endOfLine, charset);
+
+        // GlobalOptions should NOT contain .editorconfig settings - they're per-file only
+        public override AnalyzerConfigOptions GlobalOptions => new TestAnalyzerConfigOptions(null, null);
+
+        public override AnalyzerConfigOptions GetOptions(SyntaxTree tree) => _fileOptions;
+
+        public override AnalyzerConfigOptions GetOptions(AdditionalText textFile) => _fileOptions;
+    }
+
+    private class TestAnalyzerConfigOptions(string? endOfLine, string? charset) : AnalyzerConfigOptions
+    {
+        private readonly ImmutableDictionary<string, string> _options = new Dictionary<string, string?>
+        {
+            ["end_of_line"] = endOfLine,
+            ["charset"] = charset,
+        }
+            .Where(x => x.Value != null)
+            .ToImmutableDictionary(x => x.Key, x => x.Value!);
+
+        public override bool TryGetValue(string key, out string value) => _options.TryGetValue(key, out value!);
+    }
+}