Add support for multiple column names.

Author: AustinWise

src/SepCsvSourceGenerator.Analyzer/AnalyzerReleases.Unshipped.md

@@ -5,3 +5,4 @@
 
 Rule ID | Category | Severity | Notes
 --------|----------|----------|-------
+CSVGEN009 | Usage | Error | DiagnosticDescriptors

src/SepCsvSourceGenerator.Analyzer/CsvGenerator.cs

@@ -39,8 +39,7 @@ internal sealed class CsvDateFormatAttribute : CsvAttribute
                     [global::System.AttributeUsage(global::System.AttributeTargets.Property | global::System.AttributeTargets.Field, AllowMultiple = false)]
                     internal sealed class CsvHeaderNameAttribute : CsvAttribute
                     {
-                        public CsvHeaderNameAttribute(string name) { Name = name; }
-                        public string Name { get; }
+                        public CsvHeaderNameAttribute(params string[] names) { }
                     }
 
                     /// <summary>

src/SepCsvSourceGenerator.Analyzer/CsvPropertyDefinition.cs

@@ -4,7 +4,7 @@ internal record CsvPropertyDefinition(
     string Name,
     string FullTypeName, // e.g., "System.Nullable<System.Int32>"
     string UnderlyingTypeName, // e.g., "System.Int32"
-    string HeaderName,
+    string[] HeaderNames,
     string? DateFormat,
     bool IsRequiredMember,
     bool IsInitOnly,

src/SepCsvSourceGenerator.Analyzer/DiagnosticDescriptors.cs

@@ -21,4 +21,6 @@ internal static class DiagnosticDescriptors
         new("CSVGEN007", "No properties to parse", "The type '{0}' does not have any properties with the [CsvHeaderName] attribute", "Usage", DiagnosticSeverity.Warning, true);
     public static readonly DiagnosticDescriptor PropertyNotParsable =
         new("CSVGEN008", "Property not parsable", "Property '{0}' of type '{1}' is not parsable. It must be an enum or implement ISpanParsable<T>.", "Usage", DiagnosticSeverity.Error, true);
+    public static readonly DiagnosticDescriptor HeaderNamesEmpty =
+        new("CSVGEN009", "Missing header name", "Must specify one or more header names", "Usage", DiagnosticSeverity.Error, true);
 }

src/SepCsvSourceGenerator.Analyzer/Emitter.cs

@@ -159,12 +159,28 @@ private void GenerateMethod(CsvMethodDefinition methodDef)
         // Get header indices
         foreach (var prop in methodDef.PropertiesToParse)
         {
-            AppendLine($"if (!{methodDef.ReaderParameterName}.Header.TryIndexOf(\"{prop.HeaderName}\", out {prop.Name}Ndx))");
+            var tryFindIndex = string.Join(" || ", prop.HeaderNames.Select(h => $"{methodDef.ReaderParameterName}.Header.TryIndexOf(\"{h}\", out {prop.Name}Ndx)"));
+            if (prop.HeaderNames.Length == 1)
+            {
+                AppendLine($"if (!{tryFindIndex})");
+            }
+            else
+            {
+                AppendLine($"if (!({tryFindIndex}))");
+            }
             AppendLine("{");
             IncreaseIndent();
             if (prop.IsRequiredMember)
             {
-                AppendLine($"throw new global::System.ArgumentException($\"Missing required column '{prop.HeaderName}' for required property '{prop.Name}'.\");");
+                if (prop.HeaderNames.Length == 1)
+                {
+                    AppendLine($"throw new global::System.ArgumentException($\"Missing required column '{prop.HeaderNames[0]}' for required property '{prop.Name}'.\");");
+                }
+                else
+                {
+                    var headerNames = string.Join("', '", prop.HeaderNames);
+                    AppendLine($"throw new global::System.ArgumentException($\"Missing required column with any of the following names: '{headerNames}' for required property '{prop.Name}'.\");");
+                }
             }
             else
             {

src/SepCsvSourceGenerator.Analyzer/Parser.cs

@@ -122,13 +122,32 @@ public List<CsvMethodDefinition> GetCsvMethodDefinitions(ImmutableArray<MethodDe
                     // From here on, if we use "continue" we must raise a diagnostic.
                     // This ensures we will either get NoPropertiesFound or some other diagnostic if something is wrong.
 
-                    string? headerName = propertySymbol.Name;
-                    if (headerAttr != null && headerAttr.ConstructorArguments.Length == 1)
+                    string[] headerNames;
+                    if (headerAttr is not null)
                     {
-                        headerName = headerAttr.ConstructorArguments[0].Value as string;
+                        if (headerAttr.ConstructorArguments.Length == 1 &&
+                            headerAttr.ConstructorArguments[0].Kind == TypedConstantKind.Array)
+                        {
+                            var values = headerAttr.ConstructorArguments[0].Values;
+                            if (values.IsDefaultOrEmpty)
+                            {
+                                Diag(Diagnostic.Create(DiagnosticDescriptors.HeaderNamesEmpty, propertySymbol.Locations.FirstOrDefault()!, propertySymbol.Name));
+                                continue;
+                            }
+                            headerNames = [.. values.Select(c => (string)c.Value!)];
+                        }
+                        else
+                        {
+                            Debug.Fail("There should be no non-array constructor for this attribute.");
+                            continue;
+                        }
+                    }
+                    else
+                    {
+                        headerNames = [propertySymbol.Name];
                     }
 
-                    if (string.IsNullOrWhiteSpace(headerName))
+                    if (headerNames.Any(string.IsNullOrWhiteSpace))
                     {
                         Diag(Diagnostic.Create(DiagnosticDescriptors.InvalidHeaderName, propertySymbol.Locations.FirstOrDefault()!, propertySymbol.Name));
                         continue;
@@ -185,7 +204,7 @@ public List<CsvMethodDefinition> GetCsvMethodDefinitions(ImmutableArray<MethodDe
                         propertySymbol.Name,
                         propertySymbol.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat),
                         underlyingType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat),
-                        headerName!,
+                        headerNames,
                         dateFormat,
                         propertySymbol.IsRequired,
                         propertySymbol.SetMethod?.IsInitOnly ?? false,

tests/SepCsvSourceGenerator.Analyzer.Tests/Baselines/MultipleHeaderNames.generated.txt

@@ -0,0 +1,36 @@
+// <auto-generated/>
+#nullable enable
+using nietras.SeparatedValues;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+
+namespace Test
+{
+    public partial class MyRecord
+    {
+        public static async partial global::System.Collections.Generic.IAsyncEnumerable<global::Test.MyRecord> ParseRecords(SepReader reader, [EnumeratorCancellation] global::System.Threading.CancellationToken ct)
+        {
+            int NameNdx;
+
+            if (!(reader.Header.TryIndexOf("Name", out NameNdx) || reader.Header.TryIndexOf("Alias", out NameNdx)))
+            {
+                throw new global::System.ArgumentException($"Missing required column with any of the following names: 'Name', 'Alias' for required property 'Name'.");
+            }
+
+            await foreach (SepReader.Row row in reader
+                #if NET10_0_OR_GREATER
+                .WithCancellation(ct).ConfigureAwait(false)
+                #endif
+            )
+            {
+                ct.ThrowIfCancellationRequested();
+
+                global::Test.MyRecord ret = new global::Test.MyRecord()
+                {
+                    Name = row[NameNdx].Span.ToString(),
+                };
+                yield return ret;
+            }
+        }
+    }
+}

tests/SepCsvSourceGenerator.Analyzer.Tests/CsvGeneratorEmitterTests.cs

@@ -424,6 +424,31 @@ public partial class MyRecord
             RunTestAsync(source, "OptionalCancellationToken.generated.txt");
         }
 
+        [Fact]
+        public void Emitter_GeneratesCorrectCode_ForMultipleHeaderNames()
+        {
+            var source = @"
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using AWise.SepCsvSourceGenerator;
+using nietras.SeparatedValues;
+
+namespace Test
+{
+    public partial class MyRecord
+    {
+        [CsvHeaderName(""Name"", ""Alias"")]
+        public required string Name { get; init; }
+
+        [GenerateCsvParser]
+        public static partial IAsyncEnumerable<MyRecord> ParseRecords(SepReader reader, CancellationToken ct);
+    }
+}
+";
+            RunTestAsync(source, "MultipleHeaderNames.generated.txt");
+        }
+
         private static void RunTestAsync(string source, string baselineFileName)
         {
             source = "#nullable enable\n" + source;

tests/SepCsvSourceGenerator.Analyzer.Tests/CsvGeneratorParserTests.cs

@@ -49,6 +49,41 @@ public partial class MyRecord
             Assert.Empty(diagnostics);
         }
 
+        [Fact]
+        public void ValidMultipleHeaderNames()
+        {
+            var diagnostics = RunGenerator(@"
+                public partial class MyRecord
+                {
+                    [CsvHeaderName(""a"", ""b"")]
+                    public string? Name { get; set; }
+
+                    [GenerateCsvParser]
+                    public partial IAsyncEnumerable<MyRecord> Parse(SepReader reader, CancellationToken cancellationToken);
+                }
+            ");
+
+            Assert.Empty(diagnostics);
+        }
+
+        [Fact]
+        public void MissingHeaderNames()
+        {
+            var diagnostics = RunGenerator(@"
+                public partial class MyRecord
+                {
+                    [CsvHeaderName]
+                    public string? Name { get; set; }
+
+                    [GenerateCsvParser]
+                    public partial IAsyncEnumerable<MyRecord> Parse(SepReader reader, CancellationToken cancellationToken);
+                }
+            ");
+
+            var diag = Assert.Single(diagnostics);
+            Assert.Equal("CSVGEN009", diag.Id);
+        }
+
         [Fact]
         public void InitNonNullableNonRequiredPropertyGeneratesWarning()
         {

tests/SepCsvSourceGenerator.Analyzer.Tests/RunGeneratedParserTests.cs

@@ -8,7 +8,7 @@ public enum MyEnum { A, B, C }
     public class BaseRecord
     {
         [CsvHeaderName("ID")]
-        public int Id { get; set; }
+        public required int Id { get; init; }
     }
     public partial class MyRecord : BaseRecord
     {
@@ -70,6 +70,21 @@ private static void Verify(IEnumerable<MyRecord> enumerable)
         Assert.Null(item2.MissingField);
     }
 
+    [Fact]
+    public void MissingColumns()
+    {
+        using var reader = Sep.Reader().FromText("Name,Date,Enum,NullableInt\nJohn Doe,2023-01-15,A,42\nJane,2023-02-20,B,123");
+        try
+        {
+            MyRecord.Parse(reader, CancellationToken.None).ToList();
+            Assert.Fail("should throw");
+        }
+        catch (ArgumentException ex)
+        {
+            Assert.Equal("Missing required column 'ID' for required property 'Id'.", ex.Message);
+        }
+    }
+
     [Fact]
     public void CancelEnumeration()
     {
@@ -114,10 +129,7 @@ public async Task CancelEnumerationAsync(bool tokenInParseAsync, bool tokenInGet
         }
         await enumerator.DisposeAsync();
     }
-}
 
-public partial class RunGeneratedParserTests_WithNewDateTypes
-{
     public partial class MyRecordWithNewDates
     {
         [CsvHeaderName("ID")]
@@ -139,12 +151,10 @@ public partial class MyRecordWithNewDates
         public static partial IEnumerable<MyRecordWithNewDates> Parse(SepReader reader);
     }
 
-    const string CSV_CONTENT = "ID,Date,Time,Offset\n1,2024-01-01,13:14:15.123,2024-05-10T10:00:00.0000000-05:00";
-
     [Fact]
-    public void Parse()
+    public void ParseNewDates()
     {
-        using var reader = Sep.Reader().FromText(CSV_CONTENT);
+        using var reader = Sep.Reader().FromText("ID,Date,Time,Offset\n1,2024-01-01,13:14:15.123,2024-05-10T10:00:00.0000000-05:00");
         var list = MyRecordWithNewDates.Parse(reader).ToList();
         var item1 = Assert.Single(list);
 
@@ -153,4 +163,39 @@ public void Parse()
         Assert.Equal(new TimeOnly(13, 14, 15, 123), item1.Time);
         Assert.Equal(new DateTimeOffset(2024, 5, 10, 10, 0, 0, TimeSpan.FromHours(-5)), item1.Dto);
     }
+
+    public partial class MyRecordWithAliasedColumns
+    {
+        [CsvHeaderName("a", "b")]
+        public required int Value { get; init; }
+
+        [GenerateCsvParser]
+        public static partial IEnumerable<MyRecordWithAliasedColumns> Parse(SepReader reader);
+    }
+
+    [Theory]
+    [InlineData("a\n1")]
+    [InlineData("b\n1")]
+    public void ParseAliasedColumns(string fileContents)
+    {
+        using var reader = Sep.Reader().FromText(fileContents);
+        var list = MyRecordWithAliasedColumns.Parse(reader).ToList();
+        var item1 = Assert.Single(list);
+        Assert.Equal(1, item1.Value);
+    }
+
+    [Fact]
+    public void MissingAliasedColumns()
+    {
+        using var reader = Sep.Reader().FromText("whoops,1");
+        try
+        {
+            MyRecordWithAliasedColumns.Parse(reader).ToList();
+            Assert.Fail("should throw");
+        }
+        catch (ArgumentException ex)
+        {
+            Assert.Equal("Missing required column with any of the following names: 'a', 'b' for required property 'Value'.", ex.Message);
+        }
+    }
 }