Address Uno generator review feedback

Use shared mobile target defaults and WINUI3 aliases, clarify Uno 5 API support and target-framework guidance, and document the test reference baseline with additional Uno.UI coverage.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: c08f9b4b-106c-4922-b1e8-ee02d89ee263

Author: Sergio0694

components/DependencyPropertyGenerator/CommunityToolkit.DependencyPropertyGenerator.Tests/Helpers/XamlFrameworkTest.cs

@@ -19,6 +19,11 @@ namespace CommunityToolkit.GeneratedDependencyProperty.Tests.Helpers;
 /// <summary>
 /// Runs generation and analysis against an independently referenced XAML framework.
 /// </summary>
+/// <remarks>
+/// Both compilations use .NET 8 reference assemblies to cover the oldest supported modern .NET target,
+/// independently of the SDK running the tests. When raising that baseline, update both reference sets,
+/// the Basic.Reference.Assemblies.Net80 package reference, and the other test helpers together.
+/// </remarks>
 internal static class XamlFrameworkTest
 {
     public static PortableExecutableReference CreateFrameworkReference(string assemblyName, bool isInterface, string xamlNamespace = "Microsoft.UI.Xaml", string? filePath = null)

components/DependencyPropertyGenerator/CommunityToolkit.DependencyPropertyGenerator.Tests/Test_DependencyPropertyGenerator.Uno.cs

@@ -15,18 +15,22 @@ namespace CommunityToolkit.GeneratedDependencyProperty.Tests;
 partial class Test_DependencyPropertyGenerator
 {
     [TestMethod]
-    [DataRow("Uno.UI", true, false)]
-    [DataRow("Uno.UI", true, true)]
-    [DataRow("Uno.WinUI", false, false)]
-    [DataRow("Uno.WinUI", false, true)]
-    [DataRow("Uno.UI", false, false)]
-    [DataRow("Uno.UI", false, true)]
-    [DataRow("Microsoft.WinUI", false, false)]
-    public async Task XamlFramework_ValidOwners_CompileAndDoNotWarn(string assemblyName, bool isInterface, bool renamedReference)
+    [DataRow("Uno.UI", true, false, false)]
+    [DataRow("Uno.UI", true, true, false)]
+    [DataRow("Uno.WinUI", false, false, false)]
+    [DataRow("Uno.WinUI", false, true, false)]
+    [DataRow("Uno.UI", false, false, false)]
+    [DataRow("Uno.UI", false, true, false)]
+    [DataRow("Microsoft.WinUI", false, false, false)]
+    [DataRow("Uno.UI", true, false, true)]
+    [DataRow("Uno.UI", true, true, true)]
+    public async Task XamlFramework_ValidOwners_CompileAndDoNotWarn(string assemblyName, bool isInterface, bool renamedReference, bool useWindowsUIXaml)
     {
+        string xamlNamespace = useWindowsUIXaml ? "Windows.UI.Xaml" : "Microsoft.UI.Xaml";
         PortableExecutableReference frameworkReference = XamlFrameworkTest.CreateFrameworkReference(
             assemblyName,
             isInterface,
+            xamlNamespace,
             filePath: renamedReference ? @"C:\References\Unrelated.dll" : $@"C:\References\{assemblyName}.dll");
 
         const string properties = """
@@ -61,8 +65,8 @@ partial void OnCountChanged(int value) { }
 
         string source = $$"""
             using CommunityToolkit.WinUI;
-            using Microsoft.UI.Xaml;
-            using Microsoft.UI.Xaml.Controls;
+            using {{xamlNamespace}};
+            using {{xamlNamespace}}.Controls;
 
             namespace MyApp;
 
@@ -86,19 +90,19 @@ public partial class IndirectOwner : IntermediateControl
             }
             """;
 
-        Compilation compilation = XamlFrameworkTest.RunGenerator(source, frameworkReference);
+        Compilation compilation = XamlFrameworkTest.RunGenerator(source, frameworkReference, useWindowsUIXaml);
 
         XamlFrameworkTest.AssertEmits(compilation);
 
-        Assert.AreEqual(0, (await XamlFrameworkTest.GetAnalyzerDiagnosticsAsync(compilation)).Length);
+        Assert.AreEqual(0, (await XamlFrameworkTest.GetAnalyzerDiagnosticsAsync(compilation, useWindowsUIXaml)).Length);
 
         foreach (string ownerName in new[] { "DirectOwner", "ControlOwner", "IndirectOwner" })
         {
             string generatedSource = compilation.SyntaxTrees.Single(tree => Path.GetFileName(tree.FilePath) == $"MyApp.{ownerName}.g.cs").ToString();
 
-            StringAssert.Contains(generatedSource, "global::Microsoft.UI.Xaml.DependencyProperty.Register(");
+            StringAssert.Contains(generatedSource, $"global::{xamlNamespace}.DependencyProperty.Register(");
             StringAssert.Contains(generatedSource, $"ownerType: typeof({ownerName})");
-            StringAssert.Contains(generatedSource, "new global::Microsoft.UI.Xaml.PropertyMetadata(");
+            StringAssert.Contains(generatedSource, $"new global::{xamlNamespace}.PropertyMetadata(");
             StringAssert.Contains(generatedSource, "defaultValue: \"Ready\"");
             StringAssert.Contains(generatedSource, "defaultValue: 42");
             StringAssert.Contains(generatedSource, "defaultValue: default(int)");

components/DependencyPropertyGenerator/samples/DependencyPropertyGenerator.md

@@ -30,7 +30,8 @@ Install the package that matches your application's XAML framework from the [Com
 | --- | --- | --- |
 | WinUI 3 / Windows App SDK | `CommunityToolkit.Labs.WinUI.DependencyPropertyGenerator` | `Microsoft.UI.Xaml` |
 | UWP | `CommunityToolkit.Labs.Uwp.DependencyPropertyGenerator` | `Windows.UI.Xaml` |
-| Uno Platform (WinUI) | `CommunityToolkit.Labs.WinUI.DependencyPropertyGenerator` (see target frameworks below) | `Microsoft.UI.Xaml` |
+| Uno Platform 5.x (UWP API / Uno.UI) | `CommunityToolkit.Labs.Uwp.DependencyPropertyGenerator` (see target frameworks below) | `Windows.UI.Xaml` |
+| Uno Platform 5.x, 6.x, or 7.x (WinUI API / Uno.WinUI) | `CommunityToolkit.Labs.WinUI.DependencyPropertyGenerator` (see target frameworks below) | `Microsoft.UI.Xaml` |
 
 Both packages expose the attribute in the `CommunityToolkit.WinUI` namespace. Install the package in the project that declares the generated properties, not just in an application that references that project.
 
@@ -445,9 +446,11 @@ Do not combine embedded types with a reference to the package's runtime attribut
 
 ### Uno Platform
 
-The WinUI package includes attribute assemblies for `net9.0-android35.0`, `net9.0-ios18.0`, and `net9.0-maccatalyst18.0`, alongside its Windows targets. These mobile targets use Uno dependencies rather than Windows App SDK. Reference the package normally on compatible Android, iOS, and Mac Catalyst targets; embedded mode is not required.
+Both packages include attribute assemblies for Android, iOS, and Mac Catalyst, alongside their Windows targets. Mobile TFMs and platform versions follow the Toolkit's shared `MultiTarget` configuration; check the package's supported frameworks for the exact TFMs in a particular release. These mobile targets use Uno dependencies rather than Windows App SDK. Reference the package normally on compatible mobile targets; embedded mode is not required.
 
-The example uses the minimum supported C# version. Keep a newer language version if your project already uses one.
+Select the package by XAML API, not just the Uno version. Uno 5 supports both the UWP API (`Uno.UI`) and the WinUI API (`Uno.WinUI`); Uno 6 and 7 use the WinUI API. An existing Uno 5 UWP-API project can keep using `Windows.UI.Xaml` with the UWP package without migrating to the WinUI API.
+
+For a WinUI-API project, use the WinUI package. The example uses the minimum supported C# version; keep a newer language version if your project already uses one.
 
 ```xml
 <ItemGroup>
@@ -461,11 +464,20 @@ The example uses the minimum supported C# version. Keep a newer language version
 </PropertyGroup>
 ```
 
-Other Uno targets, such as desktop and WebAssembly, do not yet have attribute assemblies in this package. Use the embedded-mode setup above on those targets: set `PrivateAssets="all"` and `ExcludeAssets="compile;runtime"` on the package reference and enable `EnableGeneratedDependencyPropertyAttributeEmbeddedMode`. Enable `EnableGeneratedDependencyPropertyEmbeddedMode` too if you use `GeneratedDependencyProperty.UnsetValue`. That setup can also be applied to every target of a multi-target project; keep the package's analyzer and build assets enabled, and do not combine embedded types with a reference to the attribute assembly.
+For an Uno 5 UWP-API project, use this package reference instead, and omit the explicit `false` setting above. The UWP package defaults `DependencyPropertyGeneratorUseWindowsUIXaml` to `true`:
+
+```xml
+<ItemGroup>
+  <PackageReference Include="CommunityToolkit.Labs.Uwp.DependencyPropertyGenerator"
+                    Version="PACKAGE_VERSION" />
+</ItemGroup>
+```
+
+Other Uno targets, such as desktop and WebAssembly, do not yet have attribute assemblies in these packages. Use the embedded-mode setup above on those targets: set `PrivateAssets="all"` and `ExcludeAssets="compile;runtime"` on the appropriate package reference and enable `EnableGeneratedDependencyPropertyAttributeEmbeddedMode`. Enable `EnableGeneratedDependencyPropertyEmbeddedMode` too if you use `GeneratedDependencyProperty.UnsetValue`. That setup can also be applied to every TFM listed in a consuming project's `<TargetFrameworks>` property; this is independent of the Toolkit repository's `MultiTarget` build system. Keep the package's analyzer and build assets enabled, and do not combine embedded types with a reference to the attribute assembly.
 
-Use `Microsoft.UI.Xaml` for Uno's WinUI API, regardless of whether its types are declared in `Uno.UI` or `Uno.WinUI`. The generator resolves the referenced framework symbols; no Uno version, assembly-file naming convention, or application-specific polyfill is required.
+Use `Windows.UI.Xaml` for Uno's UWP API and `Microsoft.UI.Xaml` for its WinUI API. The WinUI API namespace is the same regardless of whether its types are declared in an assembly named `Uno.UI` or `Uno.WinUI`; assembly names do not necessarily match the NuGet package name. The generator resolves the referenced framework symbols; no Uno version detection, assembly-file naming convention, or application-specific polyfill is required.
 
-The same declarations work with Uno 6.x's interface-based `DependencyObject` and Uno 7.x's class-based layout. Uno's own generator supplies the framework implementation when a class directly implements the interface. If another imported namespace also provides a `GeneratedDependencyPropertyAttribute`, qualify the Toolkit attribute as `[CommunityToolkit.WinUI.GeneratedDependencyProperty]`.
+The same declarations work with Uno 5.x and 6.x's interface-based `DependencyObject` and Uno 7.x's class-based layout. Uno's own generator supplies the framework implementation when a class directly implements the interface. If another imported namespace also provides a `GeneratedDependencyPropertyAttribute`, qualify the Toolkit attribute as `[CommunityToolkit.WinUI.GeneratedDependencyProperty]`.
 
 ### Preserving embedded attributes
 

components/DependencyPropertyGenerator/src/CommunityToolkit.WinUI.DependencyPropertyGenerator.csproj

@@ -19,9 +19,6 @@
 
     <!-- This library doesn't need XAML support, so we can just target 17763 -->
     <UwpTargetFrameworks>uap10.0.17763;net8.0-windows10.0.17763.0;net9.0-windows10.0.17763.0;</UwpTargetFrameworks>
-    <AndroidLibTargetFrameworks>net9.0-android35.0;</AndroidLibTargetFrameworks>
-    <iOSLibTargetFrameworks>net9.0-ios18.0;</iOSLibTargetFrameworks>
-    <MacOSLibTargetFrameworks>net9.0-maccatalyst18.0;</MacOSLibTargetFrameworks>
   </PropertyGroup>
 
   <!-- Sets this up as a toolkit component's source project -->

components/DependencyPropertyGenerator/src/GeneratedDependencyProperty.cs

@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#if WINAPPSDK 
+#if WINUI3
 using DependencyProperty = Microsoft.UI.Xaml.DependencyProperty;
 #else
 using DependencyProperty = Windows.UI.Xaml.DependencyProperty;

components/DependencyPropertyGenerator/src/GeneratedDependencyPropertyAttribute.cs

@@ -6,7 +6,7 @@
 #if NET8_0_OR_GREATER
 using System.Diagnostics.CodeAnalysis;
 #endif
-#if WINAPPSDK
+#if WINUI3
 using DependencyObject = Microsoft.UI.Xaml.DependencyObject;
 using DependencyProperty = Microsoft.UI.Xaml.DependencyProperty;
 using PropertyMetadata = Microsoft.UI.Xaml.PropertyMetadata;