Qualify PCWSTR correctly in ReadOnlySpan<string> array marshaling

The friendly overload that projects a counted array of const strings
(`[Const, NativeArrayInfo] PCWSTR*`) as `ReadOnlySpan<string>` marshals via
`GCHandle`/`ArrayPool<PCWSTR>`. The temporary `ArrayPool<PCWSTR>` used the
`PCWSTRTypeSyntax` helper, which was hard-coded to the `winmdroot` alias.

For the Win32 SDK itself `winmdroot` is `Windows.Win32`, so this was correct.
But when projecting other metadata (whose `winmdroot` aliases a different
assembly, e.g. `global::OSClient`), `winmdroot.Foundation.PCWSTR` resolves to a
non-existent `OSClient.Foundation.PCWSTR` and fails to compile -- even though the
COM signature itself correctly references `global::Windows.Win32.Foundation.PCWSTR`.

Qualify the ArrayPool element type via `Win32NamespacePrefix` (as HRESULT and
other well-known types already do), so it resolves to
`global::Windows.Win32.Foundation.PCWSTR` outside the Win32 SDK and remains
`winmdroot.Foundation.PCWSTR` within it.

Extends the StringArrayInterop fixture with a counted-array interface and adds
MultiMetadataTests.StringArrayFriendlyOverloadQualifiesPcwstrCorrectly.

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

Author: jevansaks

src/Microsoft.Windows.CsWin32/Generator.FriendlyOverloads.cs

@@ -5,15 +5,21 @@ namespace Microsoft.Windows.CsWin32;
 
 public partial class Generator
 {
-    private static readonly TypeSyntax PCWSTRTypeSyntax = QualifiedName(QualifiedName(IdentifierName(GlobalWinmdRootNamespaceAlias), IdentifierName("Foundation")), IdentifierName("PCWSTR"));
-
     private enum FriendlyOverloadOf
     {
         ExternMethod,
         StructMethod,
         InterfaceMethod,
     }
 
+    /// <summary>
+    /// Gets the syntax for the <c>PCWSTR</c> type, qualified to its true location. This resolves to
+    /// <c>winmdroot.Foundation.PCWSTR</c> when generating the Win32 SDK itself, and to
+    /// <c>global::Windows.Win32.Foundation.PCWSTR</c> when projecting other metadata (whose <c>winmdroot</c>
+    /// alias points at a different assembly), matching how the parameter type itself is qualified.
+    /// </summary>
+    private TypeSyntax PCWSTRTypeSyntax => QualifiedName(QualifiedName(this.Win32NamespacePrefix, IdentifierName("Foundation")), IdentifierName("PCWSTR"));
+
     private static ParameterSyntax StripAttributes(ParameterSyntax parameter) => parameter.WithAttributeLists(default);
 
     /// <summary>
@@ -815,7 +821,7 @@ private IEnumerable<MethodDeclarationSyntax> DeclareFriendlyOverload(
                                             SyntaxKind.SimpleMemberAccessExpression,
                                             MemberAccessExpression(
                                                 SyntaxKind.SimpleMemberAccessExpression,
-                                                ParseTypeName($"global::System.Buffers.ArrayPool<{PCWSTRTypeSyntax.ToString()}>"),
+                                                ParseTypeName($"global::System.Buffers.ArrayPool<{this.PCWSTRTypeSyntax}>"),
                                                 IdentifierName("Shared")),
                                             IdentifierName("Rent")),
                                         [Argument(GetSpanLength(origName, false))])))
@@ -891,7 +897,7 @@ private IEnumerable<MethodDeclarationSyntax> DeclareFriendlyOverload(
                             InvocationExpression(
                                 MemberAccessExpression(
                                     SyntaxKind.SimpleMemberAccessExpression,
-                                    ParseTypeName($"global::System.Buffers.ArrayPool<{PCWSTRTypeSyntax.ToString()}> "),
+                                    ParseTypeName($"global::System.Buffers.ArrayPool<{this.PCWSTRTypeSyntax}> "),
                                     IdentifierName("Shared.Return")),
                                 [Argument(pcwstrLocal)]));
 

test/Microsoft.Windows.CsWin32.Tests/ExternalMetadata/StringArrayInterop.il

@@ -1,17 +1,23 @@
 // Source for StringArrayInterop.winmd.
 //
-// This fixture reproduces the friendly-overload bug hit by real UDK-generated metadata: a COM interface
-// method that takes a pointer to a const string pointer (an "_In_reads_opt_(count) LPCWSTR*" array of
-// strings) whose array-count SAL was NOT captured as a NativeArrayInfoAttribute. In metadata this is just
-// a [Const] PWSTR* parameter (which CsWin32 projects as PCWSTR*).
-//
-// Because PCWSTR is itself a pointer wrapper, such a parameter is a pointer-to-pointer and must NOT be
-// projected by the friendly-overload generator as a single "in PCWSTR" value. (When the count *is*
-// captured as NativeArrayInfo the parameter is correctly projected as a ReadOnlySpan; this fixture covers
-// the case where it is absent.)
+// This fixture reproduces two friendly-overload bugs hit by real UDK-generated metadata, where a COM
+// interface method takes a pointer to a const string pointer (an "_In_reads_opt_(count) LPCWSTR*" array of
+// strings). In metadata this is a [Const] PWSTR* parameter, which CsWin32 projects as PCWSTR*.
 //
 // The common namespace is "StringArrayInterop" (not "Windows.Win32") so the generator treats this like a
-// customer's own metadata assembly, and PWSTR/PCWSTR come from the referenced Windows.Win32 metadata.
+// customer's own metadata assembly. PWSTR/PCWSTR come from the referenced Windows.Win32 metadata, so the
+// generated PCWSTR type lives at global::Windows.Win32.Foundation.PCWSTR rather than under the local
+// "winmdroot" (= global::StringArrayInterop) alias.
+//
+//   * IStringArrayConsumer.AcceptStrings has NO NativeArrayInfo, so CsWin32 cannot tell it is an array. It
+//     must be left as a raw PCWSTR* pointer, NOT projected as a single "in PCWSTR" value (PCWSTR is itself a
+//     pointer wrapper).
+//   * ICountedStringArrayConsumer.AcceptCountedStrings HAS NativeArrayInfo, so it is projected as
+//     ReadOnlySpan<string>. The generated GCHandle/ArrayPool<PCWSTR> marshaling must qualify PCWSTR as
+//     global::Windows.Win32.Foundation.PCWSTR, not the local "winmdroot.Foundation.PCWSTR" (which would be
+//     StringArrayInterop.Foundation.PCWSTR and fail to compile).
+//
+// The trailing [out] parameter forces a friendly overload to be emitted in both cases.
 
 .assembly extern netstandard
 {
@@ -36,10 +42,7 @@
 .subsystem 0x0003
 .corflags 0x00000001
 
-// A COM interface whose method accepts an array of strings via [Const] PWSTR* (projected as PCWSTR*),
-// like IShareEngine::StopSharing's "_In_reads_opt_(cSids) LPCWSTR* ppszUserSids". The trailing [out]
-// parameter forces a friendly overload to be emitted so the projection of the string-array parameter can
-// be asserted.
+// An array of strings WITHOUT count metadata: must stay a PCWSTR* pointer (not "in PCWSTR").
 .class interface public abstract auto ansi StringArrayInterop.Apis.IStringArrayConsumer
 {
   .custom instance void [Windows.Win32.winmd]Windows.Win32.Foundation.Metadata.GuidAttribute::.ctor(uint32, uint16, uint16, uint8, uint8, uint8, uint8, uint8, uint8, uint8, uint8) = (
@@ -54,3 +57,21 @@
     .custom instance void [Windows.Win32.winmd]Windows.Win32.Foundation.Metadata.ConstAttribute::.ctor() = ( 01 00 00 00 )
   }
 }
+
+// An array of strings WITH count metadata (NativeArrayInfo -> CountParamIndex = 1): projected as
+// ReadOnlySpan<string>, exercising the ArrayPool<PCWSTR> marshaling that must qualify PCWSTR correctly.
+.class interface public abstract auto ansi StringArrayInterop.Apis.ICountedStringArrayConsumer
+{
+  .custom instance void [Windows.Win32.winmd]Windows.Win32.Foundation.Metadata.GuidAttribute::.ctor(uint32, uint16, uint16, uint8, uint8, uint8, uint8, uint8, uint8, uint8, uint8) = (
+    01 00 79 56 34 12 34 12 34 12 12 34 56 78 9A BC DE F0 00 00 )
+
+  .method public hidebysig newslot abstract virtual instance int32
+          AcceptCountedStrings([in] valuetype [Windows.Win32.winmd]Windows.Win32.Foundation.PWSTR* strings,
+                               uint32 count,
+                               [out] uint32* accepted) cil managed
+  {
+    .param [1]
+    .custom instance void [Windows.Win32.winmd]Windows.Win32.Foundation.Metadata.ConstAttribute::.ctor() = ( 01 00 00 00 )
+    .custom instance void [Windows.Win32.winmd]Windows.Win32.Foundation.Metadata.NativeArrayInfoAttribute::.ctor() = ( 01 00 01 00 53 06 0F 43 6F 75 6E 74 50 61 72 61 6D 49 6E 64 65 78 01 00 )
+  }
+}

test/Microsoft.Windows.CsWin32.Tests/ExternalMetadata/StringArrayInterop.winmd

@@ -65,4 +65,27 @@ public void PointerToStringPointerParameterIsNotProjectedAsInParameter()
             Assert.True(stringsParam.Type is PointerTypeSyntax, $"'strings' should remain a pointer but was: {stringsParam.Type}");
         }
     }
+
+    /// <summary>
+    /// Asserts that the <c>ReadOnlySpan&lt;string&gt;</c> friendly overload generated for a counted array of
+    /// strings (<c>[Const, NativeArrayInfo] PCWSTR*</c>) qualifies the <c>PCWSTR</c> type used by its
+    /// <c>ArrayPool&lt;PCWSTR&gt;</c> marshaling to <c>global::Windows.Win32.Foundation.PCWSTR</c> rather than
+    /// the local <c>winmdroot</c> alias (which, for non-Win32 metadata, points at a different assembly and
+    /// therefore fails to compile).
+    /// </summary>
+    [Fact]
+    public void StringArrayFriendlyOverloadQualifiesPcwstrCorrectly()
+    {
+        this.generator = this.CreateSuperGenerator([StringArrayInteropMetadataPath, .. DefaultMetadataPaths], DefaultTestGeneratorOptions);
+
+        // GenerateApi asserts the generated code compiles; before the fix the ArrayPool<PCWSTR> temporaries
+        // referenced StringArrayInterop.Foundation.PCWSTR (via the winmdroot alias), which does not exist.
+        this.GenerateApi("ICountedStringArrayConsumer");
+
+        MethodDeclarationSyntax friendly = Assert.Single(
+            this.FindGeneratedMethod("AcceptCountedStrings"),
+            m => m.ParameterList.Parameters.Any(p => p.Type is GenericNameSyntax { Identifier.ValueText: "ReadOnlySpan" }));
+        string body = friendly.ToFullString();
+        Assert.Contains("ArrayPool<global::Windows.Win32.Foundation.PCWSTR>", body);
+    }
 }