Added casts + disabled blocking warnings

Fixed some manual warnings as well

Author: curin

generator.json

@@ -8,7 +8,8 @@
       "Mods": [
         "ClangScraper",
         "ChangeNamespace",
-        "TransformCOM"
+        "TransformCOM",
+        "DisableWarnings"
       ],
       "ClangScraper": {
         "ClangSharpResponseFiles": [
@@ -50,8 +51,15 @@
         }
       },
       "TransformCOM": {
-        "BaseTypes": [
-          "IUnknown.Interface"
+        "BaseTypes": {
+          "IUnknown.Interface": "Silk.NET.Windows.IUnknown.Interface"
+        }
+      },
+      "DisableWarnings": {
+        "WarningCodes": [
+          "CS1589", //XML Comments missing (due to missing docs)
+          "CS0419", //Inheritdoc issue (due to bug)
+          "CA1416"  //Function available outside of target os (intended)
         ]
       }
     },

sources/SilkTouch/SilkTouch/Clang/ResponseFileHandler.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.CommandLine;
 using System.CommandLine.Parsing;
@@ -1204,7 +1204,7 @@ out Dictionary<string, string> withPackings
 
                 case "generate-doc-includes":
                 {
-                    configOptions |= PInvokeGeneratorConfigurationOptions.GenerateDocIncludes;
+                    //configOptions |= PInvokeGeneratorConfigurationOptions.GenerateDocIncludes;
                     break;
                 }
 

sources/SilkTouch/SilkTouch/Mods/Common/ModLoader.cs

@@ -30,6 +30,7 @@ public class ModLoader
             nameof(TransformProperties) => typeof(TransformProperties),
             nameof(ClangScraper) => typeof(ClangScraper),
             nameof(TransformCOM) => typeof(TransformCOM),
+            nameof(DisableWarnings) => typeof(DisableWarnings),
             _ => null,
         };
 }

sources/SilkTouch/SilkTouch/Mods/DisableWarnings.cs

@@ -0,0 +1,98 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using System.Reflection;
+using Silk.NET.SilkTouch.Utility;
+using Silk.NET.SilkTouch.Sources;
+
+namespace Silk.NET.SilkTouch.Mods
+{
+    /// <summary>
+    /// A mod to Add warning disabling pragmas
+    /// </summary>
+    /// <param name="config">The configuration to use.</param>
+    [ModConfiguration<Configuration>]
+    public class DisableWarnings(
+        IOptionsSnapshot<DisableWarnings.Configuration> config) : Mod
+    {
+        /// <summary>
+        /// The configuration for the <see cref="DisableWarnings"/> mod.
+        /// </summary>
+        public class Configuration
+        {
+            /// <summary>
+            /// Warning Codes to Disable
+            /// </summary>
+            public string[]? WarningCodes { get; init; }
+        }
+
+        /// <inheritdoc />
+        public override async Task ExecuteAsync(IModContext ctx, CancellationToken ct = default)
+        {
+            await base.ExecuteAsync(ctx, ct);
+
+            // Read the configuration.
+            var cfg = config.Get(ctx.JobKey);
+
+            if (cfg.WarningCodes is null)
+            {
+                return;
+            }
+
+            var proj = ctx.SourceProject;
+
+            // Create the pragma directive trivia
+            var pragmaDirective = Trivia(
+                                    PragmaWarningDirectiveTrivia(
+                                        Token(SyntaxKind.DisableKeyword),
+                                        true)
+                                    .WithErrorCodes(
+                                        SeparatedList<ExpressionSyntax>(
+                                            cfg.WarningCodes.Select(warn => IdentifierName(warn)))));
+
+            foreach (var docId in proj?.DocumentIds ?? [])
+            {
+                var doc =
+                    proj?.GetDocument(docId) ?? throw new InvalidOperationException("Document missing");
+                if (await doc.GetSyntaxRootAsync(ct) is not { } root)
+                {
+                    continue;
+                }
+
+                // Find the using directive
+                SyntaxNode? namespaceNode = root.DescendantNodes().OfType<FileScopedNamespaceDeclarationSyntax>().FirstOrDefault();
+                
+                if (namespaceNode == null)
+                {
+                    // Skip the case where no using directive is found
+                    continue;
+                }
+
+                // Get the leading trivia (comments) of the first using directive
+                var leadingTrivia = namespaceNode.GetLeadingTrivia();
+
+                // Insert the pragma directive after the comments
+                var newLeadingTrivia = leadingTrivia.Insert(leadingTrivia.Count, pragmaDirective)
+                    .Add(CarriageReturnLineFeed);
+
+                // Update the using directive with the new leading trivia
+                var newUsingDirective = namespaceNode.WithLeadingTrivia(newLeadingTrivia);
+
+                // Replace the old using directive with the new one in the root node
+                root = root.ReplaceNode(namespaceNode, newUsingDirective);
+                doc = doc.WithSyntaxRoot(root);
+
+                proj = doc.Project;
+            }
+
+            ctx.SourceProject = proj;
+        }
+    }
+}