Project flexible arrays as Span<byte>

Author: jevansaks

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

@@ -198,6 +198,8 @@ private IEnumerable<MethodDeclarationSyntax> DeclareFriendlyOverload(
             bool isManagedParameterType = this.IsManagedType(parameterTypeInfo);
             MemorySize? memorySize = null;
             bool mustRemainAsPointer = false;
+            bool isArray = false;
+            bool projectAsSpanBytes = false;
             bool isPointerToStructWithFlexibleArray = parameterTypeInfo is PointerTypeHandleInfo { ElementType: HandleTypeHandleInfo pointedElement } && pointedElement.Generator.IsStructWithFlexibleArray(pointedElement);
             if (this.FindInteropDecorativeAttribute(paramAttributes, MemorySizeAttribute) is CustomAttribute memorySizeAttribute)
             {
@@ -214,7 +216,20 @@ private IEnumerable<MethodDeclarationSyntax> DeclareFriendlyOverload(
             else if (memorySize is null)
             {
                 // If there's no MemorySize attribute, we may still need to keep this parameter as a pointer if it's a struct with a flexible array.
-                mustRemainAsPointer = isPointerToStructWithFlexibleArray;
+                if (isPointerToStructWithFlexibleArray)
+                {
+                    if (improvePointersToSpansAndRefs)
+                    {
+                        // FlexibleSizeArrays are easier to work with if they project as Span<byte>. Callers can request the pointer verions
+                        // via FriendlyOverloads.IncludePointerOverloads = true.
+                        isArray = true;
+                        projectAsSpanBytes = true;
+                    }
+                    else
+                    {
+                        mustRemainAsPointer = true;
+                    }
+                }
             }
             else if (!improvePointersToSpansAndRefs)
             {
@@ -239,7 +254,6 @@ private IEnumerable<MethodDeclarationSyntax> DeclareFriendlyOverload(
 
             IdentifierNameSyntax origName = IdentifierName(externParam.Identifier.ValueText);
 
-            bool isArray = false;
             bool isNullTerminated = false; // TODO
             bool isCountOfBytes = false;
             short? countParamIndex = null;
@@ -273,7 +287,6 @@ private IEnumerable<MethodDeclarationSyntax> DeclareFriendlyOverload(
                 isCountOfBytes = true;
             }
 
-            bool projectAsSpanBytes = false;
             if (improvePointersToSpansAndRefs && IsVoidPtrOrPtrPtr(externParam.Type))
             {
                 // if it's memory-sized project as Span<byte>
@@ -1002,7 +1015,7 @@ bool TryHandleCountParam(TypeSyntax elementType, bool nullableSource)
                     if (externParam.Type is PointerTypeSyntax)
                     {
                         remainsRefType = false;
-                        if (isCountOfBytes)
+                        if (isCountOfBytes || isPointerToStructWithFlexibleArray)
                         {
                             // For parameters annotated as count of bytes, we need to switch the friendly parameter to Span<byte>
                             // and then cast to (ParamType*) when we call the p/invoke.

test/CsWin32Generator.Tests/CsWin32GeneratorTests.cs

@@ -209,6 +209,8 @@ public async Task PointerReturnValueIsPreserved()
         ["CancelIoEx", "CancelIoEx", "SafeHandle hFile, global::System.Threading.NativeOverlapped* lpOverlapped"],
         ["ITypeInfo", "GetNames", "this winmdroot.System.Com.ITypeInfo @this, int memid, Span<winmdroot.Foundation.BSTR> rgBstrNames, out uint pcNames"],
         ["EnumProcessModules", "EnumProcessModules", "SafeHandle hProcess, Span<byte> lphModule, out uint lpcbNeeded"],
+        ["AdjustTokenPrivileges", "AdjustTokenPrivileges", "SafeHandle TokenHandle, winmdroot.Foundation.BOOL DisableAllPrivileges, Span<byte> NewState, Span<byte> PreviousState, out uint ReturnLength"],
+        ["IMAPIStatus", "FlushQueues", "nuint ulUIParam, ReadOnlySpan<byte> lpTargetTransport, uint ulFlags"],
     ];
 
     [Theory]