Fix source generator diagnostics to support #pragma warning disable

src/libraries/Microsoft.Extensions.Configuration.Binder/gen/ConfigurationBindingGenerator.Parser.cs

@@ -30,13 +30,13 @@ internal sealed partial class Parser(CompilationData compilationData)
             private bool _emitEnumParseMethod;
             private bool _emitGenericParseEnum;
 
-            public List<DiagnosticInfo>? Diagnostics { get; private set; }
+            public List<Diagnostic>? Diagnostics { get; private set; }
 
             public SourceGenerationSpec? GetSourceGenerationSpec(ImmutableArray<BinderInvocation?> invocations, CancellationToken cancellationToken)
             {
                 if (!_langVersionIsSupported)
                 {
-                    RecordDiagnostic(DiagnosticDescriptors.LanguageVersionNotSupported, trimmedLocation: Location.None);
+                    RecordDiagnostic(DiagnosticDescriptors.LanguageVersionNotSupported, location: Location.None);
                     return null;
                 }
 
@@ -979,10 +979,10 @@ private void ReportContainingTypeDiagnosticIfRequired(TypeParseInfo typeParseInf
                 }
             }
 
-            private void RecordDiagnostic(DiagnosticDescriptor descriptor, Location trimmedLocation, params object?[]? messageArgs)
+            private void RecordDiagnostic(DiagnosticDescriptor descriptor, Location location, params object?[]? messageArgs)
             {
-                Diagnostics ??= new List<DiagnosticInfo>();
-                Diagnostics.Add(DiagnosticInfo.Create(descriptor, trimmedLocation, messageArgs));
+                Diagnostics ??= new List<Diagnostic>();
+                Diagnostics.Add(Diagnostic.Create(descriptor, location, messageArgs));
             }
 
             private void CheckIfToEmitParseEnumMethod()

src/libraries/Microsoft.Extensions.Configuration.Binder/gen/ConfigurationBindingGenerator.cs

@@ -6,10 +6,10 @@
 using System.Diagnostics;
 using System.Reflection;
 using System.Threading;
+using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using SourceGenerators;
 
 namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration
 {
@@ -37,7 +37,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                         ? new CompilationData((CSharpCompilation)compilation)
                         : null);
 
-            IncrementalValueProvider<(SourceGenerationSpec?, ImmutableEquatableArray<DiagnosticInfo>?)> genSpec = context.SyntaxProvider
+            IncrementalValueProvider<(SourceGenerationSpec?, ImmutableArray<Diagnostic>)> genSpec = context.SyntaxProvider
                 .CreateSyntaxProvider(
                     (node, _) => BinderInvocation.IsCandidateSyntaxNode(node),
                     BinderInvocation.Create)
@@ -48,14 +48,16 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 {
                     if (tuple.Right is not CompilationData compilationData)
                     {
-                        return (null, null);
+                        return (null, ImmutableArray<Diagnostic>.Empty);
                     }
 
                     try
                     {
                         Parser parser = new(compilationData);
                         SourceGenerationSpec? spec = parser.GetSourceGenerationSpec(tuple.Left, cancellationToken);
-                        ImmutableEquatableArray<DiagnosticInfo>? diagnostics = parser.Diagnostics?.ToImmutableEquatableArray();
+                        ImmutableArray<Diagnostic> diagnostics = parser.Diagnostics is { } diags
+                            ? diags.ToImmutableArray()
+                            : ImmutableArray<Diagnostic>.Empty;
                         return (spec, diagnostics);
                     }
                     catch (Exception ex)
@@ -65,7 +67,26 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 })
                 .WithTrackingName(GenSpecTrackingName);
 
-            context.RegisterSourceOutput(genSpec, ReportDiagnosticsAndEmitSource);
+            // Project the combined pipeline result to just the equatable model, discarding diagnostics.
+            // SourceGenerationSpec implements value equality, so Roslyn's Select operator will compare
+            // successive model snapshots and only propagate changes downstream when the model structurally
+            // differs. This ensures source generation is fully incremental: re-emitting code only when
+            // the binding spec actually changes, not on every keystroke or positional shift.
+            IncrementalValueProvider<SourceGenerationSpec?> sourceGenerationSpec =
+                genSpec.Select(static (t, _) => t.Item1);
+
+            context.RegisterSourceOutput(sourceGenerationSpec, EmitSource);
+
+            // Project to just the diagnostics, discarding the model. ImmutableArray<Diagnostic> does not
+            // implement value equality, so Roslyn's incremental pipeline uses reference equality for these
+            // values — the callback fires on every compilation change. This is by design: diagnostic
+            // emission is cheap, and we need fresh SourceLocation instances that are pragma-suppressible
+            // (cf. https://github.com/dotnet/runtime/issues/92509).
+            // No source code is generated from this pipeline — it exists solely to report diagnostics.
+            IncrementalValueProvider<ImmutableArray<Diagnostic>> diagnostics =
+                genSpec.Select(static (t, _) => t.Item2);
+
+            context.RegisterSourceOutput(diagnostics, EmitDiagnostics);
 
             if (!s_hasInitializedInterceptorVersion)
             {
@@ -136,17 +157,17 @@ internal static int DetermineInterceptableVersion()
         /// </summary>
         public Action<SourceGenerationSpec>? OnSourceEmitting { get; init; }
 
-        private void ReportDiagnosticsAndEmitSource(SourceProductionContext sourceProductionContext, (SourceGenerationSpec? SourceGenerationSpec, ImmutableEquatableArray<DiagnosticInfo>? Diagnostics) input)
+        private static void EmitDiagnostics(SourceProductionContext context, ImmutableArray<Diagnostic> diagnostics)
         {
-            if (input.Diagnostics is ImmutableEquatableArray<DiagnosticInfo> diagnostics)
+            foreach (Diagnostic diagnostic in diagnostics)
             {
-                foreach (DiagnosticInfo diagnostic in diagnostics)
-                {
-                    sourceProductionContext.ReportDiagnostic(diagnostic.CreateDiagnostic());
-                }
+                context.ReportDiagnostic(diagnostic);
             }
+        }
 
-            if (input.SourceGenerationSpec is SourceGenerationSpec spec)
+        private void EmitSource(SourceProductionContext sourceProductionContext, SourceGenerationSpec? spec)
+        {
+            if (spec is not null)
             {
                 OnSourceEmitting?.Invoke(spec);
                 Emitter emitter = new(spec);

src/libraries/Microsoft.Extensions.Configuration.Binder/gen/Microsoft.Extensions.Configuration.Binder.SourceGeneration.csproj

@@ -30,7 +30,6 @@
     <Compile Include="$(CommonPath)\Roslyn\DiagnosticDescriptorHelper.cs" Link="Common\Roslyn\DiagnosticDescriptorHelper.cs" />
     <Compile Include="$(CommonPath)\Roslyn\GetBestTypeByMetadataName.cs" Link="Common\Roslyn\GetBestTypeByMetadataName.cs" />
     <Compile Include="$(CommonPath)\SourceGenerators\CSharpSyntaxUtilities.cs" Link="Common\SourceGenerators\CSharpSyntaxUtilities.cs" />
-    <Compile Include="$(CommonPath)\SourceGenerators\DiagnosticInfo.cs" Link="Common\SourceGenerators\DiagnosticInfo.cs" />
     <Compile Include="$(CommonPath)\SourceGenerators\ImmutableEquatableArray.cs" Link="Common\SourceGenerators\ImmutableEquatableArray.cs" />
     <Compile Include="$(CommonPath)\SourceGenerators\SourceWriter.cs" Link="Common\SourceGenerators\SourceWriter.cs" />
     <Compile Include="$(CommonPath)\SourceGenerators\TypeModelHelper.cs" Link="Common\SourceGenerators\TypeModelHelper.cs" />

src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/GeneratorTests.cs

@@ -12,6 +12,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
@@ -414,5 +415,129 @@ public class AnotherGraphWithUnsupportedMembers
             Assert.True(result.Diagnostics.Any(diag => diag.Id == Diagnostics.TypeNotSupported.Id));
             Assert.True(result.Diagnostics.Any(diag => diag.Id == Diagnostics.PropertyNotSupported.Id));
         }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
+        public async Task Diagnostic_HasPragmaSuppressibleLocation()
+        {
+            // SYSLIB1103: ValueTypesInvalidForBind (Warning, configurable).
+            string source = """
+                #pragma warning disable SYSLIB1103
+                using System;
+                using Microsoft.Extensions.Configuration;
+
+                public class Program
+                {
+                    public static void Main()
+                    {
+                        ConfigurationBuilder configurationBuilder = new();
+                        IConfigurationRoot config = configurationBuilder.Build();
+
+                        int myInt = 1;
+                        config.Bind(myInt);
+                    }
+                }
+                """;
+
+            ConfigBindingGenRunResult result = await RunGeneratorAndUpdateCompilation(source);
+            var effective = CompilationWithAnalyzers.GetEffectiveDiagnostics(result.Diagnostics, result.OutputCompilation);
+            Diagnostic diagnostic = Assert.Single(effective, d => d.Id == "SYSLIB1103");
+            Assert.True(diagnostic.IsSuppressed);
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
+        public async Task Diagnostic_NoPragma_IsNotSuppressed()
+        {
+            string source = """
+                using System;
+                using Microsoft.Extensions.Configuration;
+
+                public class Program
+                {
+                    public static void Main()
+                    {
+                        ConfigurationBuilder configurationBuilder = new();
+                        IConfigurationRoot config = configurationBuilder.Build();
+
+                        int myInt = 1;
+                        config.Bind(myInt);
+                    }
+                }
+                """;
+
+            ConfigBindingGenRunResult result = await RunGeneratorAndUpdateCompilation(source);
+            var effective = CompilationWithAnalyzers.GetEffectiveDiagnostics(result.Diagnostics, result.OutputCompilation);
+            Diagnostic diagnostic = Assert.Single(effective, d => d.Id == "SYSLIB1103");
+            Assert.False(diagnostic.IsSuppressed);
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
+        public async Task Diagnostic_MultipleDiagnostics_OnlySomeSuppressed()
+        {
+            string source = """
+                using System;
+                using System.Collections.Immutable;
+                using System.Text;
+                using System.Text.Json;
+                using Microsoft.Extensions.Configuration;
+
+                public class Program
+                {
+                    public static void Main()
+                    {
+                        ConfigurationBuilder configurationBuilder = new();
+                        IConfigurationRoot config = configurationBuilder.Build();
+
+                        // SYSLIB1103 suppressed for this call only.
+                        #pragma warning disable SYSLIB1103
+                        int myInt = 1;
+                        config.Bind(myInt);
+                        #pragma warning restore SYSLIB1103
+
+                        // SYSLIB1103 NOT suppressed for this call.
+                        long myLong = 1;
+                        config.Bind(myLong);
+                    }
+                }
+                """;
+
+            ConfigBindingGenRunResult result = await RunGeneratorAndUpdateCompilation(source);
+            var effective = CompilationWithAnalyzers.GetEffectiveDiagnostics(result.Diagnostics, result.OutputCompilation)
+                .Where(d => d.Id == "SYSLIB1103")
+                .ToList();
+
+            Assert.Equal(2, effective.Count);
+            Assert.Single(effective, d => d.IsSuppressed);
+            Assert.Single(effective, d => !d.IsSuppressed);
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))]
+        public async Task Diagnostic_PragmaRestoreOutsideSpan_IsNotSuppressed()
+        {
+            string source = """
+                using System;
+                using Microsoft.Extensions.Configuration;
+
+                public class Program
+                {
+                    public static void Main()
+                    {
+                        ConfigurationBuilder configurationBuilder = new();
+                        IConfigurationRoot config = configurationBuilder.Build();
+
+                        // Suppress and restore BEFORE the diagnostic site.
+                        #pragma warning disable SYSLIB1103
+                        #pragma warning restore SYSLIB1103
+
+                        int myInt = 1;
+                        config.Bind(myInt);
+                    }
+                }
+                """;
+
+            ConfigBindingGenRunResult result = await RunGeneratorAndUpdateCompilation(source);
+            var effective = CompilationWithAnalyzers.GetEffectiveDiagnostics(result.Diagnostics, result.OutputCompilation);
+            Diagnostic diagnostic = Assert.Single(effective, d => d.Id == "SYSLIB1103");
+            Assert.False(diagnostic.IsSuppressed);
+        }
     }
 }

src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Parser.cs

@@ -38,7 +38,7 @@ internal sealed class Parser
             private readonly INamedTypeSymbol _stringSymbol;
             private readonly Action<Diagnostic>? _reportDiagnostic;
 
-            public List<DiagnosticInfo> Diagnostics { get; } = new();
+            public List<Diagnostic> Diagnostics { get; } = new();
 
             public Parser(
                 INamedTypeSymbol loggerMessageAttribute,
@@ -811,12 +811,14 @@ private static string GenerateClassName(TypeDeclarationSyntax typeDeclaration)
 
             private void Diag(DiagnosticDescriptor desc, Location? location, params object?[]? messageArgs)
             {
+                Diagnostic diagnostic = Diagnostic.Create(desc, location, messageArgs);
+
                 // Report immediately if callback is provided (preserves pragma suppression with original locations)
-                _reportDiagnostic?.Invoke(Diagnostic.Create(desc, location, messageArgs));
+                _reportDiagnostic?.Invoke(diagnostic);
 
                 // Also collect for scenarios that need the diagnostics list; in Roslyn 4.0+ incremental generators,
-                // this list is exposed via parser.Diagnostics (as ImmutableEquatableArray<DiagnosticInfo>) and reported in Execute.
-                Diagnostics.Add(DiagnosticInfo.Create(desc, location, messageArgs));
+                // this list is exposed via parser.Diagnostics and reported in the diagnostic pipeline.
+                Diagnostics.Add(diagnostic);
             }
 
             private static bool IsBaseOrIdentity(ITypeSymbol source, ITypeSymbol dest, Compilation compilation)