chore: add .NET Framework polyfills and fix MAUI Visibility ambiguity (#4)

* Fix .NET Framework build errors and MAUI Visibility ambiguity

- Add RequiresUnreferencedCodeAttribute polyfill for net462/net472/net481
  targets where the attribute is inaccessible (only public in .NET 5+)
- Add ModuleInitializerAttribute polyfill for benchmark net462 target
- Fix CS0104 Visibility ambiguity in MAUI project on Windows targets by
  using type aliases instead of namespace imports

* Fix remaining .NET Framework polyfill and visibility issues

- Add InternalsVisibleTo from ReactiveUI.Binding to Wpf, WinForms, and
  Maui projects so they can access internal polyfill attributes
  (RequiresUnreferencedCodeAttribute, NotNullWhenAttribute, etc.)
- Add missing using for POCOObservableForProperty in MAUI's
  DependencyObjectObservableForProperty.cs
- Emit ModuleInitializerAttribute polyfill from source generator for
  consumer projects targeting .NET Framework (same pattern as existing
  CallerArgumentExpressionAttribute polyfill)

* Remove all polyfill emission from source generator

The generator should never emit polyfills into consumer projects.
Instead it detects platform capabilities and generates appropriate code:

- Remove CallerArgumentExpressionAttribute polyfill emission; the
  supportsCallerArgExpr flag now checks both C# 10+ language version
  AND that the attribute exists in the compilation, falling back to
  file/line dispatch when unavailable
- Remove [ModuleInitializer] from generated registration code entirely
- Replace [ModuleInitializer] in ReactiveUI benchmarks with explicit
  static constructor calls using an atomic bool guard pattern
- Update snapshot tests

Author: glennawatson

src/ReactiveUI.Binding.Maui/BooleanToVisibilityTypeConverter.cs

@@ -3,9 +3,9 @@
 // See the LICENSE file in the project root for full license information.
 
 #if WINUI_TARGET
-using Microsoft.UI.Xaml;
+using Visibility = Microsoft.UI.Xaml.Visibility;
 #else
-using Microsoft.Maui;
+using Visibility = Microsoft.Maui.Visibility;
 #endif
 
 namespace ReactiveUI.Binding.Maui;

src/ReactiveUI.Binding.Maui/DependencyObjectObservableForProperty.cs

@@ -9,6 +9,8 @@
 
 using Microsoft.UI.Xaml;
 
+using ReactiveUI.Binding.ObservableForProperty;
+
 namespace ReactiveUI.Binding.Maui;
 
 /// <summary>

src/ReactiveUI.Binding.Maui/VisibilityToBooleanTypeConverter.cs

@@ -3,9 +3,9 @@
 // See the LICENSE file in the project root for full license information.
 
 #if WINUI_TARGET
-using Microsoft.UI.Xaml;
+using Visibility = Microsoft.UI.Xaml.Visibility;
 #else
-using Microsoft.Maui;
+using Visibility = Microsoft.Maui.Visibility;
 #endif
 
 namespace ReactiveUI.Binding.Maui;

src/ReactiveUI.Binding.SourceGenerators/BindingGenerator.cs

@@ -22,27 +22,15 @@ public class BindingGenerator : IIncrementalGenerator
     /// <inheritdoc/>
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
-        // Detect C# language version for CallerArgumentExpression support (C# 10+)
-        var supportsCallerArgExpr = context.ParseOptionsProvider.Select(static (opts, _) =>
-            opts is CSharpParseOptions csharpOpts
-            && csharpOpts.LanguageVersion >= LanguageVersion.CSharp10);
-
-        // Conditionally emit CallerArgumentExpression polyfill when C# 10+ but attribute is missing
-        var needsPolyfill = supportsCallerArgExpr
+        // Detect whether the consumer project supports CallerArgumentExpression (C# 10+ AND attribute available).
+        // When supported, invocation generators use expression-text dispatch; otherwise file/line dispatch.
+        var supportsCallerArgExpr = context.ParseOptionsProvider
             .Combine(context.CompilationProvider)
             .Select(static (data, _) =>
-                data.Left && data.Right.GetTypeByMetadataName(
-                    Constants.CallerArgumentExpressionAttributeMetadataName) is null);
-
-        context.RegisterSourceOutput(needsPolyfill, static (ctx, needs) =>
-        {
-            if (needs)
-            {
-                ctx.AddSource(
-                    "CallerArgumentExpressionAttribute.g.cs",
-                    Constants.CallerArgumentExpressionAttributeSource);
-            }
-        });
+                data.Left is CSharpParseOptions csharpOpts
+                && csharpOpts.LanguageVersion >= LanguageVersion.CSharp10
+                && data.Right.GetTypeByMetadataName(
+                    Constants.CallerArgumentExpressionAttributeMetadataName) is not null);
 
         // Pipeline A: Shared type detection
         // One pass: sets flags for IRO, INPC, WpfDP, WinUIDP, KVO, etc.

src/ReactiveUI.Binding.SourceGenerators/Constants.cs

@@ -45,26 +45,4 @@ internal static class Constants
     internal const string CallerFilePathAttributeName = "System.Runtime.CompilerServices.CallerFilePathAttribute";
     internal const string CallerLineNumberAttributeName = "System.Runtime.CompilerServices.CallerLineNumberAttribute";
     internal const string CallerArgumentExpressionAttributeMetadataName = "System.Runtime.CompilerServices.CallerArgumentExpressionAttribute";
-
-    /// <summary>
-    /// Polyfill source for CallerArgumentExpressionAttribute when targeting runtimes that don't include it.
-    /// Only emitted when C# 10+ is detected and the attribute is not already available.
-    /// </summary>
-    internal const string CallerArgumentExpressionAttributeSource = """
-        // <auto-generated/>
-        #pragma warning disable
-        namespace System.Runtime.CompilerServices
-        {
-            [global::System.AttributeUsage(global::System.AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
-            internal sealed class CallerArgumentExpressionAttribute : global::System.Attribute
-            {
-                public CallerArgumentExpressionAttribute(string parameterName)
-                {
-                    ParameterName = parameterName;
-                }
-
-                public string ParameterName { get; }
-            }
-        }
-        """;
 }

src/ReactiveUI.Binding.SourceGenerators/Generators/RegistrationGenerator.cs

@@ -13,7 +13,7 @@ namespace ReactiveUI.Binding.SourceGenerators.Generators;
 
 /// <summary>
 /// Consolidates all per-kind fallback generator results into a single RegisterSourceOutput.
-/// Generates all ICreatesObservableForProperty implementations and one [ModuleInitializer] class.
+/// Generates all ICreatesObservableForProperty implementations and a registration class.
 /// </summary>
 internal static class RegistrationGenerator
 {
@@ -58,7 +58,7 @@ internal static IncrementalValueProvider<ImmutableArray<ObservableTypeInfo>> Con
     }
 
     /// <summary>
-    /// Generates the consolidated registration output: all per-kind binder classes + [ModuleInitializer].
+    /// Generates the consolidated registration output: all per-kind binder classes.
     /// </summary>
     /// <param name="context">The source production context.</param>
     /// <param name="allTypes">All detected observable type infos across all notification kinds.</param>
@@ -93,7 +93,6 @@ internal static class __GeneratedBinderRegistration
                     /// <summary>
                     /// Registers all generated binders with the Splat service locator.
                     /// </summary>
-                    [global::System.Runtime.CompilerServices.ModuleInitializer]
                     internal static void Initialize()
                     {
                         // Generated binder registrations will be added here in future phases.

src/ReactiveUI.Binding/Polyfills/RequiresUnreferencedCodeAttribute.cs

@@ -0,0 +1,51 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+// Polyfill implementation adapted from SimonCropp/Polyfill
+// https://github.com/SimonCropp/Polyfill
+#if !NET
+
+namespace System.Diagnostics.CodeAnalysis;
+
+/// <summary>
+/// Indicates that the specified method requires dynamic access to code that is not referenced
+/// statically, for example through <see cref="System.Reflection"/>.
+/// </summary>
+/// <remarks>
+/// Link: https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.codeanalysis.requiresunreferencedcodeattribute.
+/// </remarks>
+[ExcludeFromCodeCoverage]
+[DebuggerNonUserCode]
+[AttributeUsage(
+    AttributeTargets.Method |
+    AttributeTargets.Constructor |
+    AttributeTargets.Class,
+    Inherited = false)]
+internal sealed class RequiresUnreferencedCodeAttribute : Attribute
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RequiresUnreferencedCodeAttribute"/> class
+    /// with the specified message.
+    /// </summary>
+    /// <param name="message">A message that contains information about the usage of unreferenced code.</param>
+    public RequiresUnreferencedCodeAttribute(string message) =>
+        Message = message;
+
+    /// <summary>
+    /// Gets a message that contains information about the usage of unreferenced code.
+    /// </summary>
+    public string Message { get; }
+
+    /// <summary>
+    /// Gets or sets an optional URL that contains more information about the method,
+    /// why it requires unreferenced code, and what options a consumer has to deal with it.
+    /// </summary>
+    public string? Url { get; set; }
+}
+
+#else
+using System.Runtime.CompilerServices;
+
+[assembly: TypeForwardedTo(typeof(System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute))]
+#endif

src/ReactiveUI.Binding/ReactiveUI.Binding.csproj

@@ -10,6 +10,9 @@
   <ItemGroup>
     <InternalsVisibleTo Include="ReactiveUI.Binding.Tests" />
     <InternalsVisibleTo Include="ReactiveUI.Binding.GeneratedCode.Tests" />
+    <InternalsVisibleTo Include="ReactiveUI.Binding.Wpf" />
+    <InternalsVisibleTo Include="ReactiveUI.Binding.WinForms" />
+    <InternalsVisibleTo Include="ReactiveUI.Binding.Maui" />
   </ItemGroup>
 
   <ItemGroup>

src/benchmarks/ReactiveUI.Binding.Benchmarks.ReactiveUI/ModuleInitializer.cs

@@ -2,25 +2,31 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using System.Runtime.CompilerServices;
-
 using ReactiveUI.Builder;
 
 using Splat;
 
 namespace ReactiveUI.Binding.Benchmarks;
 
 /// <summary>
-/// Module initializer that configures ReactiveUI before any benchmarks run.
+/// One-shot initializer that configures ReactiveUI before any benchmarks run.
+/// Call <see cref="EnsureInitialized"/> from each benchmark class's static constructor.
 /// </summary>
 internal static class ModuleInitializer
 {
+    private static int _initialized;
+
     /// <summary>
-    /// Initializes ReactiveUI using the builder pattern.
+    /// Ensures ReactiveUI is initialized exactly once, regardless of how many
+    /// benchmark classes call this method.
     /// </summary>
-    [ModuleInitializer]
-    internal static void Initialize()
+    internal static void EnsureInitialized()
     {
+        if (Interlocked.Exchange(ref _initialized, 1) != 0)
+        {
+            return;
+        }
+
         ModeDetector.OverrideModeDetector(new BenchmarkModeDetector());
         RxAppBuilder.CreateReactiveUIBuilder()
             .WithCoreServices()

src/benchmarks/ReactiveUI.Binding.Benchmarks.ReactiveUI/ReactiveUIBindingBenchmark.cs

@@ -24,6 +24,8 @@ public class ReactiveUIBindingBenchmark
     private BenchmarkViewModel _source = null!;
     private BenchmarkView _target = null!;
 
+    static ReactiveUIBindingBenchmark() => ModuleInitializer.EnsureInitialized();
+
     /// <summary>
     /// Sets up fresh source and target objects before each benchmark iteration.
     /// </summary>