Merge branch 'strict-bind' of https://github.com/DapperLib/DapperAOT into strict-bind

# Conflicts:
#	test/Dapper.AOT.Test/Interceptors/QueryStrictBind.output.netfx.cs
#	test/Dapper.AOT.Test/Interceptors/QueryStrictBind.output.netfx.txt

Author: mgravell

docs/rules/DAP049.md

@@ -1,4 +1,4 @@
 # DAP049
 
-When using `[StrictBind(...)]`, the elements should be the member names on the corresponding type. This error simply means that Dapper
+When using `[QueryColumns(...)]`, the elements should be the member names on the corresponding type. This error simply means that Dapper
 could not find a member you specified. You can skip unwanted columns by passing `null` or `""`.

src/Dapper.AOT.Analyzers/CodeAnalysis/DapperAnalyzer.cs

@@ -665,12 +665,11 @@ internal static Location SharedParseArgsAndFlags(in ParseState ctx, IInvocationO
             }
         }
 
-        if (flags.HasAll(OperationFlags.BindResultsByName) && GetClosestDapperAttribute(ctx, op, Types.StrictBindAttribute) is not null)
+        if (flags.HasFlag(OperationFlags.Query) && (IsEnabled(ctx, op, Types.StrictTypesAttribute, out _)))
         {
-            flags |= OperationFlags.StrictBind;
+            flags |= OperationFlags.StrictTypes;
         }
 
-
         if (exitFirstFailure && flags.HasAny(OperationFlags.DoNotGenerate))
         {
             resultType = null;
@@ -781,7 +780,7 @@ enum ParameterMode
             }
         }
 
-        ImmutableArray<string> strictBind = default;
+        ImmutableArray<string> queryColumns = default;
         int? batchSize = null;
         foreach (var attrib in methodAttribs)
         {
@@ -820,8 +819,8 @@ enum ParameterMode
                             batchSize = batchTmp;
                         }
                         break;
-                    case Types.StrictBindAttribute:
-                        strictBind = ParseStrictBindColumns(attrib);
+                    case Types.QueryColumnsAttribute:
+                        queryColumns = ParseQueryColumns(attrib);
                         break;
                 }
             }
@@ -851,8 +850,8 @@ enum ParameterMode
         }
 
 
-        return cmdProps.IsDefaultOrEmpty && rowCountHint <= 0 && rowCountHintMember is null && batchSize is null && strictBind.IsDefault
-            ? null : new(rowCountHint, rowCountHintMember?.Member.Name, batchSize, cmdProps, strictBind);
+        return cmdProps.IsDefaultOrEmpty && rowCountHint <= 0 && rowCountHintMember is null && batchSize is null && queryColumns.IsDefault
+            ? null : new(rowCountHint, rowCountHintMember?.Member.Name, batchSize, cmdProps, queryColumns);
     }
 
     static void ValidateParameters(MemberMap? parameters, OperationFlags flags, Action<Diagnostic> onDiagnostic)

src/Dapper.AOT.Analyzers/CodeAnalysis/DapperInterceptorGenerator.Single.cs

@@ -92,7 +92,7 @@ static void WriteSingleImplementation(
                         break;
                 }
             }
-            sb.AppendReader(resultType, readers, additionalCommandState?.StrictBind ?? default);
+            sb.AppendReader(resultType, readers, additionalCommandState?.QueryColumns ?? default);
         }
         else if (flags.HasAny(OperationFlags.Execute))
         {

src/Dapper.AOT.Analyzers/CodeAnalysis/DapperInterceptorGenerator.cs

@@ -391,7 +391,7 @@ internal void Generate(in GenerateState ctx)
 
             if (flags.HasAny(OperationFlags.GetRowParser))
             {
-                WriteGetRowParser(sb, resultType, readers, grp.Key.AdditionalCommandState?.StrictBind ?? default);
+                WriteGetRowParser(sb, resultType, readers, grp.Key.AdditionalCommandState?.QueryColumns ?? default);
             }
             else if (!TryWriteMultiExecImplementation(sb, flags, commandTypeMode, parameterType, grp.Key.ParameterMap, grp.Key.UniqueLocation is not null, methodParameters, factories, fixedSql, additionalCommandState))
             {
@@ -451,7 +451,7 @@ internal void Generate(in GenerateState ctx)
 
         foreach (var tuple in readers)
         {
-            WriteRowFactory(ctx, sb, tuple.Type, tuple.Index, tuple.StrictBind, null /* TODO */);
+            WriteRowFactory(ctx, sb, tuple.Type, tuple.Index, tuple.QueryColumns, null /* TODO */);
         }
 
         foreach (var tuple in factories)
@@ -468,9 +468,9 @@ internal void Generate(in GenerateState ctx)
         ctx.ReportDiagnostic(Diagnostic.Create(Diagnostics.InterceptorsGenerated, null, callSiteCount, ctx.Nodes.Length, methodIndex, factories.Count(), readers.Count()));
     }
 
-    private static void WriteGetRowParser(CodeWriter sb, ITypeSymbol? resultType, in RowReaderState readers, ImmutableArray<string> strictBind)
+    private static void WriteGetRowParser(CodeWriter sb, ITypeSymbol? resultType, in RowReaderState readers, ImmutableArray<string> queryColumns)
     {
-        sb.Append("return ").AppendReader(resultType, readers, strictBind)
+        sb.Append("return ").AppendReader(resultType, readers, queryColumns)
             .Append(".GetRowParser(reader, startIndex, length, returnNullIfFirstMissing);").NewLine();
     }
 
@@ -732,7 +732,7 @@ static bool IsReserved(string name)
         }
     }
 
-    private static void WriteRowFactory(in GenerateState context, CodeWriter sb, ITypeSymbol type, int index, ImmutableArray<string> strictBind, Location? location)
+    private static void WriteRowFactory(in GenerateState context, CodeWriter sb, ITypeSymbol type, int index, ImmutableArray<string> queryColumns, Location? location)
     {
         var map = MemberMap.CreateForResults(type);
         if (map is null) return;
@@ -780,7 +780,7 @@ void WriteRowFactoryFooter()
         void WriteTokenizeMethod()
         {
             sb.Append("public override object? Tokenize(global::System.Data.Common.DbDataReader reader, global::System.Span<int> tokens, int columnOffset)").Indent().NewLine();
-            if (strictBind.IsDefault) // don't emit any tokens for strict binding
+            if (queryColumns.IsDefault) // don't emit any tokens for strict binding
             {
                 sb.Append("for (int i = 0; i < tokens.Length; i++)").Indent().NewLine()
                     .Append("int token = -1;").NewLine()
@@ -808,11 +808,11 @@ void WriteTokenizeMethod()
             }
             else
             {
-                sb.Append("// strict-bind: ");
-                for (int i = 0; i < strictBind.Length; i++)
+                sb.Append("// query columns: ");
+                for (int i = 0; i < queryColumns.Length; i++)
                 {
                     if (i != 0) sb.Append(", ");
-                    var name = strictBind[i];
+                    var name = queryColumns[i];
                     if (string.IsNullOrWhiteSpace(name))
                     {
                         sb.Append("(n/a)");
@@ -826,7 +826,7 @@ void WriteTokenizeMethod()
                         sb.Append("'").Append(name).Append("'");
                     }
                 }
-                sb.NewLine().Append("global::System.Diagnostics.Debug.Assert(tokens.Length == ").Append(strictBind.Length).Append(""", "Strict-bind column count mismatch");""").NewLine();
+                sb.NewLine().Append("global::System.Diagnostics.Debug.Assert(tokens.Length >= ").Append(queryColumns.Length).Append(""", "Query columns count mismatch");""").NewLine();
             }
             sb.Append("return null;").Outdent().NewLine();
         }
@@ -879,15 +879,16 @@ void WriteReadMethod(in GenerateState context)
             }
 
             ImmutableArray<ElementMember> readMembers;
-            if (strictBind.IsDefault)
+            if (queryColumns.IsDefault)
             {
                 readMembers = members; // try to parse everything
                 sb.Append("foreach (var token in tokens)");
             }
             else
             {
-                readMembers = MapStrictBind(context, members, strictBind, location);
-                sb.Append("for (int token = 0; token < tokens.Length; token++) // strict-bind");
+                readMembers = MapQueryColumns(context, members, queryColumns, location);
+                sb.Append("int lim = global::System.Math.Min(tokens.Length, ").Append(queryColumns.Length).Append(");").NewLine()
+                    .Append("for (int token = 0; token < lim; token++) // query-columns predefined");
             }
             sb.Indent().NewLine().Append("switch (token)").Indent().NewLine();
 
@@ -920,7 +921,7 @@ void WriteReadMethod(in GenerateState context)
 
                     sb.NewLine().Append("break;").NewLine().Outdent(false);
 
-                    if (strictBind.IsDefault) // type-forgiving version; only emitted when not using strict-bind
+                    if (queryColumns.IsDefault) // type-forgiving version; only emitted when not using strict-bind
                     {
                         sb.Append("case ").Append(token + map.Members.Length).Append(":").NewLine().Indent(false);
 
@@ -1020,27 +1021,27 @@ void WriteDeferredMethodArgs()
         }
     }
 
-    private static ImmutableArray<ElementMember> MapStrictBind(in GenerateState state, ImmutableArray<ElementMember> members, ImmutableArray<string> strictBind, Location? location)
+    private static ImmutableArray<ElementMember> MapQueryColumns(in GenerateState state, ImmutableArray<ElementMember> members, ImmutableArray<string> queryColumns, Location? location)
     {
-        if (strictBind.IsDefault) return members; // not bound
+        if (queryColumns.IsDefault) return members; // not bound
 
-        var result = ImmutableArray.CreateBuilder<ElementMember>(strictBind.Length);
-        foreach (var seek in strictBind)
+        var result = ImmutableArray.CreateBuilder<ElementMember>(queryColumns.Length);
+        foreach (var seek in queryColumns)
         {
             ElementMember found = default;
             if (!string.IsNullOrWhiteSpace(seek))
             {
-                foreach (var member in members)
+                foreach (var member in members) // look for direct match
                 {
-                    if (member.CodeName == seek)
+                    if (string.Equals(member.CodeName, seek, StringComparison.InvariantCultureIgnoreCase))
                     {
                         found = member;
                         break;
                     }
                 }
-                if (found.Member is null)
+                if (found.Member is null) // additional underscore-etc deviation
                 {
-                    var normalizedSeek = StringHashing.Normalize(seek);
+                    var normalizedSeek = StringHashing.Normalize(seek); // note: should already *be* normalized, but: be sure
                     foreach (var member in members)
                     {
                         if (StringHashing.NormalizedEquals(member.CodeName, normalizedSeek))

src/Dapper.AOT.Analyzers/Internal/AdditionalCommandState.cs

@@ -38,7 +38,7 @@ internal sealed class AdditionalCommandState : IEquatable<AdditionalCommandState
     public readonly int? BatchSize;
     public readonly string? RowCountHintMemberName;
     public readonly ImmutableArray<CommandProperty> CommandProperties;
-    public readonly ImmutableArray<string> StrictBind;
+    public readonly ImmutableArray<string> QueryColumns;
 
     public bool HasRowCountHint => RowCountHint > 0 || RowCountHintMemberName is not null;
 
@@ -76,7 +76,7 @@ private static AdditionalCommandState Combine(AdditionalCommandState inherited,
 
         return new(count, countMember, inherited.BatchSize ?? overrides.BatchSize,
             Concat(inherited.CommandProperties, overrides.CommandProperties),
-            overrides.StrictBind.IsDefault ? inherited.StrictBind : overrides.StrictBind);
+            overrides.QueryColumns.IsDefault ? inherited.QueryColumns : overrides.QueryColumns);
     }
 
     static ImmutableArray<CommandProperty> Concat(ImmutableArray<CommandProperty> x, ImmutableArray<CommandProperty> y)
@@ -91,13 +91,13 @@ static ImmutableArray<CommandProperty> Concat(ImmutableArray<CommandProperty> x,
 
     internal AdditionalCommandState(
         int rowCountHint, string? rowCountHintMemberName, int? batchSize,
-        ImmutableArray<CommandProperty> commandProperties, ImmutableArray<string> strictBind)
+        ImmutableArray<CommandProperty> commandProperties, ImmutableArray<string> queryColumns)
     {
         RowCountHint = rowCountHint;
         RowCountHintMemberName = rowCountHintMemberName;
         BatchSize = batchSize;
         CommandProperties = commandProperties;
-        StrictBind = strictBind;
+        QueryColumns = queryColumns;
     }
 
 
@@ -110,7 +110,7 @@ public bool Equals(in AdditionalCommandState other)
         && BatchSize == other.BatchSize
         && RowCountHintMemberName == other.RowCountHintMemberName
         && ((CommandProperties.IsDefaultOrEmpty && other.CommandProperties.IsDefaultOrEmpty) || Equals(CommandProperties, other.CommandProperties))
-        && StrictBind.Equals(other.StrictBind);
+        && QueryColumns.Equals(other.QueryColumns);
 
     private static bool Equals(in ImmutableArray<CommandProperty> x, in ImmutableArray<CommandProperty> y)
     {
@@ -150,5 +150,5 @@ public override int GetHashCode()
         => (RowCountHint + BatchSize.GetValueOrDefault()
         + (RowCountHintMemberName is null ? 0 : RowCountHintMemberName.GetHashCode()))
         ^ (CommandProperties.IsDefaultOrEmpty ? 0 : GetHashCode(in CommandProperties))
-        ^ StrictBind.GetHashCode();
+        ^ QueryColumns.GetHashCode();
 }

src/Dapper.AOT.Analyzers/Internal/CodeWriter.cs

@@ -328,15 +328,15 @@ public string ToStringRecycle()
         return s;
     }
 
-    internal CodeWriter AppendReader(ITypeSymbol? resultType, RowReaderState readers, ImmutableArray<string> strictBind)
+    internal CodeWriter AppendReader(ITypeSymbol? resultType, RowReaderState readers, ImmutableArray<string> queryColumns)
     {
         if (IsInbuilt(resultType, out var helper))
         {
             return Append("global::Dapper.RowFactory.Inbuilt.").Append(helper);
         }
         else
         {
-            return Append("RowFactory").Append(readers.GetIndex(resultType!, strictBind)).Append(".Instance");
+            return Append("RowFactory").Append(readers.GetIndex(resultType!, queryColumns)).Append(".Instance");
         }
 
         static bool IsInbuilt(ITypeSymbol? type, out string? helper)

src/Dapper.AOT.Analyzers/Internal/Inspection.cs

@@ -147,7 +147,7 @@ public static bool IsEnabled(in ParseState ctx, IOperation op, string attributeN
         return false;
     }
 
-    public static ImmutableArray<string> ParseStrictBindColumns(AttributeData attrib)
+    public static ImmutableArray<string> ParseQueryColumns(AttributeData attrib)
     {
         ImmutableArray<string> result = default;
         if (attrib is not null && attrib.ConstructorArguments.Length == 1
@@ -170,7 +170,7 @@ public static ImmutableArray<string> ParseStrictBindColumns(AttributeData attrib
                             arr[i] = "";
                             break;
                         case string s when s.IndexOf('\x03') < 0:
-                            arr[i] = s;
+                            arr[i] = string.IsNullOrWhiteSpace(s) ? "" : StringHashing.Normalize(s);
                             break;
                         default:
                             fail = true;
@@ -1580,6 +1580,6 @@ enum OperationFlags
     KnownParameters = 1 << 21,
     QueryMultiple = 1 << 22,
     GetRowParser = 1 << 23,
-    StrictBind = 1 << 24,
+    StrictTypes = 1 << 24,
     NotAotSupported = 1 << 31,
 }

src/Dapper.AOT.Analyzers/Internal/RowReaderState.cs

@@ -6,26 +6,26 @@
 
 namespace Dapper.Internal;
 
-internal readonly struct RowReaderState : IEnumerable<(ITypeSymbol Type, ImmutableArray<string> StrictBind, int Index)>
+internal readonly struct RowReaderState : IEnumerable<(ITypeSymbol Type, ImmutableArray<string> QueryColumns, int Index)>
 {
     public RowReaderState() { }
-    private readonly Dictionary<(ITypeSymbol Type, ImmutableArray<string> StrictBind), int> resultTypes = new ();
+    private readonly Dictionary<(ITypeSymbol Type, ImmutableArray<string> QueryColumns), int> resultTypes = new ();
 
     public int Count() => resultTypes.Count();
 
-    public IEnumerator<(ITypeSymbol Type, ImmutableArray<string> StrictBind, int Index)> GetEnumerator()
+    public IEnumerator<(ITypeSymbol Type, ImmutableArray<string> QueryColumns, int Index)> GetEnumerator()
     {
         // retain discovery order
-        return resultTypes.OrderBy(x => x.Value).Select(x => (x.Key.Type, x.Key.StrictBind, x.Value)).GetEnumerator();
+        return resultTypes.OrderBy(x => x.Value).Select(x => (x.Key.Type, x.Key.QueryColumns, x.Value)).GetEnumerator();
     }
 
     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
-    public int GetIndex(ITypeSymbol type, ImmutableArray<string> strictBind)
+    public int GetIndex(ITypeSymbol type, ImmutableArray<string> queryColumns)
     {
-        if (!resultTypes.TryGetValue((type, strictBind), out var index))
+        if (!resultTypes.TryGetValue((type, queryColumns), out var index))
         {
-            resultTypes.Add((type, strictBind), index = resultTypes.Count);
+            resultTypes.Add((type, queryColumns), index = resultTypes.Count);
         }
         return index;
     }

src/Dapper.AOT.Analyzers/Internal/Types.cs

@@ -15,7 +15,8 @@ public const string
         IDynamicParameters = nameof(IDynamicParameters),
         IncludeLocationAttribute = nameof(IncludeLocationAttribute),
         SqlSyntaxAttribute = nameof(SqlSyntaxAttribute),
-        StrictBindAttribute = nameof(StrictBindAttribute),
+        StrictTypesAttribute = nameof(StrictTypesAttribute),
+        QueryColumnsAttribute = nameof(QueryColumnsAttribute),
         RowCountAttribute = nameof(RowCountAttribute),
         RowCountHintAttribute = nameof(RowCountHintAttribute),
         SqlAttribute = nameof(SqlAttribute),

src/Dapper.AOT/QueryColumnsAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Immutable;
+using System.ComponentModel;
+using System.Diagnostics;
+
+namespace Dapper;
+
+/// <summary>
+/// Specifies the ordered columns returned by a query.
+/// </summary>
+/// <param name="columns"></param>
+[AttributeUsage(AttributeTargets.Method)]
+[ImmutableObject(true), Conditional("DEBUG")]
+public sealed class QueryColumnsAttribute(params string[] columns) : Attribute
+{
+    /// <summary>
+    /// The ordered columns returned by a query.
+    /// </summary>
+    public ImmutableArray<string> Columns { get; } = columns.ToImmutableArray();
+}