Add ToString() methods to ordinary typedef structs

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

@@ -197,20 +197,37 @@ private StructDeclarationSyntax DeclareTypeDefStruct(TypeDefinition typeDef, Typ
         {
             case "PWSTR":
             case "PSTR":
-                members = members.AddRange(this.ExtractMembersFromTemplate(name.Identifier.ValueText));
+                members = AddOrReplaceMembers(members, this.ExtractMembersFromTemplate(name.Identifier.ValueText));
                 this.TryGenerateType("Windows.Win32.Foundation.PC" + name.Identifier.ValueText.Substring(1)); // the template references its constant version
                 break;
             case "BSTR":
             case "HRESULT":
             case "NTSTATUS":
             case "BOOL":
             case "BOOLEAN":
-                members = members.AddRange(this.ExtractMembersFromTemplate(name.Identifier.ValueText));
+                members = AddOrReplaceMembers(members, this.ExtractMembersFromTemplate(name.Identifier.ValueText));
                 break;
             default:
                 break;
         }
 
+        SyntaxList<MemberDeclarationSyntax> AddOrReplaceMembers(SyntaxList<MemberDeclarationSyntax> members, IEnumerable<MemberDeclarationSyntax> adds)
+        {
+            foreach (MemberDeclarationSyntax add in adds)
+            {
+                if (add is BaseMethodDeclarationSyntax addedMethod && members.FirstOrDefault(m => m is BaseMethodDeclarationSyntax existingMethod && IsSignatureMatch(addedMethod, existingMethod)) is MethodDeclarationSyntax replacedMethod)
+                {
+                    members = members.Replace(replacedMethod, addedMethod);
+                }
+                else
+                {
+                    members = members.Add(add);
+                }
+            }
+
+            return members;
+        }
+
         SyntaxTokenList structModifiers = TokenList(TokenWithSpace(this.Visibility));
         if (RequiresUnsafe(fieldInfo.FieldType))
         {
@@ -336,6 +353,13 @@ private IEnumerable<MemberDeclarationSyntax> CreateCommonTypeDefMembers(Identifi
             .AddModifiers(TokenWithSpace(SyntaxKind.PublicKeyword), TokenWithSpace(SyntaxKind.OverrideKeyword))
             .WithExpressionBody(ArrowExpressionClause(hashExpr))
             .WithSemicolonToken(SemicolonWithLineFeed);
+
+        // public override string ToString() => $"0x{this.Value:x}";
+        string valueAsNumber = fieldType is PointerTypeSyntax ? "(nuint)this.Value" : "this.Value";
+        yield return MethodDeclaration(PredefinedType(TokenWithSpace(SyntaxKind.StringKeyword)), Identifier(nameof(object.ToString)))
+            .AddModifiers(TokenWithSpace(SyntaxKind.PublicKeyword), TokenWithSpace(SyntaxKind.OverrideKeyword))
+            .WithExpressionBody(ArrowExpressionClause(SyntaxFactory.ParseExpression("$\"0x{" + valueAsNumber + ":x}\"")))
+            .WithSemicolonToken(SemicolonWithLineFeed);
     }
 
     private List<string> GetAlsoUsableForValues(TypeDefinition typeDef)

src/Microsoft.Windows.CsWin32/SimpleSyntaxFactory.cs

@@ -474,4 +474,38 @@ internal static ExpressionSyntax ToExpressionSyntax(PrimitiveTypeCode primitiveT
             _ => throw new NotSupportedException($"Unrecognized primitive type code: {primitiveTypeCode}."),
         };
     }
+
+    internal static bool IsSignatureMatch(BaseMethodDeclarationSyntax a, BaseMethodDeclarationSyntax b)
+    {
+        if (a.GetType() != b.GetType())
+        {
+            return false;
+        }
+
+        if (a is MethodDeclarationSyntax aMethod && b is MethodDeclarationSyntax bMethod)
+        {
+            if (aMethod.Identifier.ValueText != bMethod.Identifier.ValueText)
+            {
+                return false;
+            }
+        }
+
+        if (a.ParameterList.Parameters.Count != b.ParameterList.Parameters.Count)
+        {
+            return false;
+        }
+
+        // Check parameter types
+        for (int i = 0; i < a.ParameterList.Parameters.Count; i++)
+        {
+            ParameterSyntax aParam = a.ParameterList.Parameters[i];
+            ParameterSyntax bParam = b.ParameterList.Parameters[i];
+            if (aParam.Type?.ToString() != bParam.Type?.ToString())
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
 }