add [StrictBind(...)]

Author: mgravell

docs/rules/DAP049.md

@@ -0,0 +1,4 @@
+# DAP049
+
+When using `[StrictBind(...)]`, 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.Diagnostics.cs

@@ -56,6 +56,7 @@ public static readonly DiagnosticDescriptor
         AmbiguousProperties = LibraryWarning("DAP046", "Ambiguous properties", "Properties have same name '{0}' after normalization and can be conflated"),
         AmbiguousFields = LibraryWarning("DAP047", "Ambiguous fields", "Fields have same name '{0}' after normalization and can be conflated"),
         MoveFromDbString = LibraryWarning("DAP048", "Move from DbString to DbValue", "DbString achieves the same as [DbValue] does. Use it instead."),
+        BoundMemberNotFound = LibraryError("DAP049", "Bound member not found", "The bound member '{0}' was not found"),
 
         // SQL parse specific
         GeneralSqlError = SqlWarning("DAP200", "SQL error", "SQL error: {0}"),
@@ -103,7 +104,6 @@ public static readonly DiagnosticDescriptor
         ConcatenatedStringSqlExpression = SqlWarning("DAP242", "Concatenated string usage", "Data values should not be concatenated into SQL string - use parameters instead"),
         InvalidDatepartToken = SqlWarning("DAP243", "Valid datepart token expected", "Date functions require a recognized datepart argument"),
         SelectAggregateMismatch = SqlWarning("DAP244", "SELECT aggregate mismatch", "SELECT has mixture of aggregate and non-aggregate expressions"),
-        PseudoPositionalParameter = SqlError("DAP245", "Avoid SQL pseudo-positional parameter", "It is more like Dapper will incorrectly treat this literal as a pseudo-positional parameter")
-        ;
+        PseudoPositionalParameter = SqlError("DAP245", "Avoid SQL pseudo-positional parameter", "It is more like Dapper will incorrectly treat this literal as a pseudo-positional parameter");
     }
 }

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

@@ -665,6 +665,12 @@ internal static Location SharedParseArgsAndFlags(in ParseState ctx, IInvocationO
             }
         }
 
+        if (flags.HasAll(OperationFlags.BindResultsByName) && GetClosestDapperAttribute(ctx, op, Types.StrictBindAttribute) is not null)
+        {
+            flags |= OperationFlags.StrictBind;
+        }
+
+
         if (exitFirstFailure && flags.HasAny(OperationFlags.DoNotGenerate))
         {
             resultType = null;
@@ -775,6 +781,7 @@ enum ParameterMode
             }
         }
 
+        ImmutableArray<string> strictBind = default;
         int? batchSize = null;
         foreach (var attrib in methodAttribs)
         {
@@ -813,6 +820,9 @@ enum ParameterMode
                             batchSize = batchTmp;
                         }
                         break;
+                    case Types.StrictBindAttribute:
+                        strictBind = ParseStrictBindColumns(attrib);
+                        break;
                 }
             }
         }
@@ -841,8 +851,8 @@ enum ParameterMode
         }
 
 
-        return cmdProps.IsDefaultOrEmpty && rowCountHint <= 0 && rowCountHintMember is null && batchSize is null
-            ? null : new(rowCountHint, rowCountHintMember?.Member.Name, batchSize, cmdProps);
+        return cmdProps.IsDefaultOrEmpty && rowCountHint <= 0 && rowCountHintMember is null && batchSize is null && strictBind.IsDefault
+            ? null : new(rowCountHint, rowCountHintMember?.Member.Name, batchSize, cmdProps, strictBind);
     }
 
     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);
+            sb.AppendReader(resultType, readers, additionalCommandState?.StrictBind ?? 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);
+                WriteGetRowParser(sb, resultType, readers, grp.Key.AdditionalCommandState?.StrictBind ?? default);
             }
             else if (!TryWriteMultiExecImplementation(sb, flags, commandTypeMode, parameterType, grp.Key.ParameterMap, grp.Key.UniqueLocation is not null, methodParameters, factories, fixedSql, additionalCommandState))
             {
@@ -449,9 +449,9 @@ internal void Generate(in GenerateState ctx)
         }
         sb.NewLine();
 
-        foreach (var pair in readers)
+        foreach (var tuple in readers)
         {
-            WriteRowFactory(ctx, sb, pair.Type, pair.Index);
+            WriteRowFactory(ctx, sb, tuple.Type, tuple.Index, tuple.StrictBind, 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)
+    private static void WriteGetRowParser(CodeWriter sb, ITypeSymbol? resultType, in RowReaderState readers, ImmutableArray<string> strictBind)
     {
-        sb.Append("return ").AppendReader(resultType, readers)
+        sb.Append("return ").AppendReader(resultType, readers, strictBind)
             .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)
+    private static void WriteRowFactory(in GenerateState context, CodeWriter sb, ITypeSymbol type, int index, ImmutableArray<string> strictBind, Location? location)
     {
         var map = MemberMap.CreateForResults(type);
         if (map is null) return;
@@ -761,7 +761,7 @@ private static void WriteRowFactory(in GenerateState context, CodeWriter sb, ITy
         WriteRowFactoryHeader();
 
         WriteTokenizeMethod();
-        WriteReadMethod();
+        WriteReadMethod(context);
 
         WriteRowFactoryFooter();
 
@@ -780,31 +780,57 @@ 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();
-            sb.Append("for (int i = 0; i < tokens.Length; i++)").Indent().NewLine()
-                .Append("int token = -1;").NewLine()
-                .Append("var name = reader.GetName(columnOffset);").NewLine()
-                .Append("var type = reader.GetFieldType(columnOffset);").NewLine()
-                .Append("switch (NormalizedHash(name))").Indent().NewLine();
+            if (strictBind.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()
+                    .Append("var name = reader.GetName(columnOffset);").NewLine()
+                    .Append("var type = reader.GetFieldType(columnOffset);").NewLine()
+                    .Append("switch (NormalizedHash(name))").Indent().NewLine();
 
-            int token = 0;
-            foreach (var member in members)
-            {
-                var dbName = member.DbName;
-                sb.Append("case ").Append(StringHashing.NormalizedHash(dbName))
-                    .Append(" when NormalizedEquals(name, ")
-                    .AppendVerbatimLiteral(StringHashing.Normalize(dbName)).Append("):").Indent(false).NewLine()
-                    .Append("token = type == typeof(").Append(Inspection.MakeNonNullable(member.CodeType)).Append(") ? ").Append(token)
-                    .Append(" : ").Append(token + map.Members.Length).Append(";")
-                    .Append(token == 0 ? " // two tokens for right-typed and type-flexible" : "").NewLine()
-                    .Append("break;").Outdent(false).NewLine();
-                token++;
+                int token = 0;
+                foreach (var member in members)
+                {
+                    var dbName = member.DbName;
+                    sb.Append("case ").Append(StringHashing.NormalizedHash(dbName))
+                        .Append(" when NormalizedEquals(name, ")
+                        .AppendVerbatimLiteral(StringHashing.Normalize(dbName)).Append("):").Indent(false).NewLine()
+                        .Append("token = type == typeof(").Append(Inspection.MakeNonNullable(member.CodeType)).Append(") ? ").Append(token)
+                        .Append(" : ").Append(token + map.Members.Length).Append(";")
+                        .Append(token == 0 ? " // two tokens for right-typed and type-flexible" : "").NewLine()
+                        .Append("break;").Outdent(false).NewLine();
+                    token++;
+                }
+                sb.Outdent().NewLine()
+                    .Append("tokens[i] = token;").NewLine()
+                    .Append("columnOffset++;").NewLine()
+                    .Outdent().NewLine();
             }
-            sb.Outdent().NewLine()
-                .Append("tokens[i] = token;").NewLine()
-                .Append("columnOffset++;").NewLine();
-            sb.Outdent().NewLine().Append("return null;").Outdent().NewLine();
+            else
+            {
+                sb.Append("// strict-bind: ");
+                for (int i = 0; i < strictBind.Length; i++)
+                {
+                    if (i != 0) sb.Append(", ");
+                    var name = strictBind[i];
+                    if (string.IsNullOrWhiteSpace(name))
+                    {
+                        sb.Append("(n/a)");
+                    }
+                    else if (CompiledRegex.SimpleName.IsMatch(name))
+                    {
+                        sb.Append(name);
+                    }
+                    else
+                    {
+                        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.Append("return null;").Outdent().NewLine();
         }
-        void WriteReadMethod()
+        void WriteReadMethod(in GenerateState context)
         {
             const string DeferredConstructionVariableName = "value";
 
@@ -852,47 +878,63 @@ void WriteReadMethod()
                     ? type.WithNullableAnnotation(NullableAnnotation.None) : type).Append(" result = new();").NewLine();
             }
 
-            sb.Append("foreach (var token in tokens)").Indent().NewLine()
-            .Append("switch (token)").Indent().NewLine();
+            ImmutableArray<ElementMember> readMembers;
+            if (strictBind.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");
+            }
+            sb.Indent().NewLine().Append("switch (token)").Indent().NewLine();
 
             token = 0;
-            foreach (var member in members)
+            foreach (var member in readMembers)
             {
-                var memberType = member.CodeType;
+                if (member.Member is not null) // exclude non-mapped bindings
+                {
+                    var memberType = member.CodeType;
 
-                member.GetDbType(out var readerMethod);
-                var nullCheck = Inspection.CouldBeNullable(memberType) ? $"reader.IsDBNull(columnOffset) ? ({CodeWriter.GetTypeName(memberType.WithNullableAnnotation(NullableAnnotation.Annotated))})null : " : "";
-                sb.Append("case ").Append(token).Append(":").NewLine().Indent(false);
+                    member.GetDbType(out var readerMethod);
+                    var nullCheck = Inspection.CouldBeNullable(memberType) ? $"reader.IsDBNull(columnOffset) ? ({CodeWriter.GetTypeName(memberType.WithNullableAnnotation(NullableAnnotation.Annotated))})null : " : "";
+                    sb.Append("case ").Append(token).Append(":").NewLine().Indent(false);
 
-                // write `result.X = ` or `member0 = `
-                if (useDeferredConstruction) sb.Append(DeferredConstructionVariableName).Append(token);
-                else sb.Append("result.").Append(member.CodeName);
-                sb.Append(" = ");
+                    // write `result.X = ` or `member0 = `
+                    if (useDeferredConstruction) sb.Append(DeferredConstructionVariableName).Append(token);
+                    else sb.Append("result.").Append(member.CodeName);
+                    sb.Append(" = ");
 
-                sb.Append(nullCheck);
-                if (readerMethod is null)
-                {
-                    sb.Append("reader.GetFieldValue<").Append(memberType).Append(">(columnOffset);");
-                }
-                else
-                {
-                    sb.Append("reader.").Append(readerMethod).Append("(columnOffset);");
-                }
+                    sb.Append(nullCheck);
+                    if (readerMethod is null)
+                    {
+                        sb.Append("reader.GetFieldValue<").Append(memberType).Append(">(columnOffset);");
+                    }
+                    else
+                    {
+                        sb.Append("reader.").Append(readerMethod).Append("(columnOffset);");
+                    }
 
 
-                sb.NewLine().Append("break;").NewLine().Outdent(false)
-                    .Append("case ").Append(token + map.Members.Length).Append(":").NewLine().Indent(false);
+                    sb.NewLine().Append("break;").NewLine().Outdent(false);
 
-                // write `result.X = ` or `member0 = `
-                if (useDeferredConstruction) sb.Append(DeferredConstructionVariableName).Append(token);
-                else sb.Append("result.").Append(member.CodeName);
+                    if (strictBind.IsDefault) // type-forgiving version; only emitted when not using strict-bind
+                    {
+                        sb.Append("case ").Append(token + map.Members.Length).Append(":").NewLine().Indent(false);
 
-                sb.Append(" = ")
-                    .Append(nullCheck)
-                    .Append("GetValue<")
-                    .Append(Inspection.MakeNonNullable(memberType)).Append(">(reader, columnOffset);").NewLine()
-                    .Append("break;").NewLine().Outdent(false);
+                        // write `result.X = ` or `member0 = `
+                        if (useDeferredConstruction) sb.Append(DeferredConstructionVariableName).Append(token);
+                        else sb.Append("result.").Append(member.CodeName);
 
+                        sb.Append(" = ")
+                            .Append(nullCheck)
+                            .Append("GetValue<")
+                            .Append(Inspection.MakeNonNullable(memberType)).Append(">(reader, columnOffset);").NewLine()
+                            .Append("break;").NewLine().Outdent(false);
+                    }
+                }
                 token++;
             }
 
@@ -978,6 +1020,46 @@ void WriteDeferredMethodArgs()
         }
     }
 
+    private static ImmutableArray<ElementMember> MapStrictBind(in GenerateState state, ImmutableArray<ElementMember> members, ImmutableArray<string> strictBind, Location? location)
+    {
+        if (strictBind.IsDefault) return members; // not bound
+
+        var result = ImmutableArray.CreateBuilder<ElementMember>(strictBind.Length);
+        foreach (var seek in strictBind)
+        {
+            ElementMember found = default;
+            if (!string.IsNullOrWhiteSpace(seek))
+            {
+                foreach (var member in members)
+                {
+                    if (member.CodeName == seek)
+                    {
+                        found = member;
+                        break;
+                    }
+                }
+                if (found.Member is null)
+                {
+                    var normalizedSeek = StringHashing.Normalize(seek);
+                    foreach (var member in members)
+                    {
+                        if (StringHashing.NormalizedEquals(member.CodeName, normalizedSeek))
+                        {
+                            found = member;
+                            break;
+                        }
+                    }
+                }
+                if (found.Member is null)
+                {
+                    state.ReportDiagnostic(Diagnostic.Create(DapperAnalyzer.Diagnostics.BoundMemberNotFound, location, seek));
+                }
+            }
+            result.Add(found);
+        }
+        return result.ToImmutable();
+    }
+
     [Flags]
     enum WriteArgsFlags
     {

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

@@ -38,6 +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 bool HasRowCountHint => RowCountHint > 0 || RowCountHintMemberName is not null;
 
@@ -74,7 +75,8 @@ private static AdditionalCommandState Combine(AdditionalCommandState inherited,
         }
 
         return new(count, countMember, inherited.BatchSize ?? overrides.BatchSize,
-            Concat(inherited.CommandProperties, overrides.CommandProperties));
+            Concat(inherited.CommandProperties, overrides.CommandProperties),
+            overrides.StrictBind.IsDefault ? inherited.StrictBind : overrides.StrictBind);
     }
 
     static ImmutableArray<CommandProperty> Concat(ImmutableArray<CommandProperty> x, ImmutableArray<CommandProperty> y)
@@ -89,12 +91,13 @@ static ImmutableArray<CommandProperty> Concat(ImmutableArray<CommandProperty> x,
 
     internal AdditionalCommandState(
         int rowCountHint, string? rowCountHintMemberName, int? batchSize,
-        ImmutableArray<CommandProperty> commandProperties)
+        ImmutableArray<CommandProperty> commandProperties, ImmutableArray<string> strictBind)
     {
         RowCountHint = rowCountHint;
         RowCountHintMemberName = rowCountHintMemberName;
         BatchSize = batchSize;
         CommandProperties = commandProperties;
+        StrictBind = strictBind;
     }
 
 
@@ -106,7 +109,8 @@ public bool Equals(in AdditionalCommandState other)
         => RowCountHint == other.RowCountHint
         && BatchSize == other.BatchSize
         && RowCountHintMemberName == other.RowCountHintMemberName
-        && ((CommandProperties.IsDefaultOrEmpty && other.CommandProperties.IsDefaultOrEmpty) || Equals(CommandProperties, other.CommandProperties));
+        && ((CommandProperties.IsDefaultOrEmpty && other.CommandProperties.IsDefaultOrEmpty) || Equals(CommandProperties, other.CommandProperties))
+        && StrictBind.Equals(other.StrictBind);
 
     private static bool Equals(in ImmutableArray<CommandProperty> x, in ImmutableArray<CommandProperty> y)
     {
@@ -145,5 +149,6 @@ static int GetHashCode(in ImmutableArray<CommandProperty> x)
     public override int GetHashCode()
         => (RowCountHint + BatchSize.GetValueOrDefault()
         + (RowCountHintMemberName is null ? 0 : RowCountHintMemberName.GetHashCode()))
-        ^ (CommandProperties.IsDefaultOrEmpty ? 0 : GetHashCode(in CommandProperties));
+        ^ (CommandProperties.IsDefaultOrEmpty ? 0 : GetHashCode(in CommandProperties))
+        ^ StrictBind.GetHashCode();
 }