XML Visiting

src/generators/Silk.NET.SilkTouch.Scraper/ClangScraper.cs

@@ -27,7 +27,27 @@ public sealed class ClangScraper
     /// Placeholder used in place of library paths
     /// </summary>
     public static readonly string LibraryNamespacePlaceholder = "LIBRARY_NAMESPACE";
-
+
+    /// <summary>
+    /// Scrapes the given XML document for symbols
+    /// </summary>
+    /// <param name="document">A XML Document, the format is assumed to be similar to what ClangSharp would output.</param>
+    /// <returns>Any number of symbols scraped from the given xml</returns>
+    public IEnumerable<Symbol> ScrapeXML(XmlDocument document)
+    {
+        var bindings = document.ChildNodes.Cast<XmlNode>().FirstOrDefault(x => x.LocalName == "bindings" && x is XmlElement) as XmlElement;
+
+        if (bindings is null)
+        {
+            return Enumerable.Empty<Symbol>();
+        }
+
+        var visitor = new XmlVisitor();
+        visitor.Visit(bindings);
+
+        return visitor.Symbols;
+    }
+
     /// <summary>
     /// Calls into Clang to generate XML used to scrape symbols.
     /// </summary>

src/generators/Silk.NET.SilkTouch.Scraper/XmlVisitor.cs

@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using Silk.NET.SilkTouch.Symbols;
+
+namespace Silk.NET.SilkTouch.Scraper;
+
+internal sealed class XmlVisitor
+{
+    private List<Symbol> _symbols = new();
+
+    public IEnumerable<Symbol> Symbols => _symbols;
+
+    public void Visit(XmlNode node)
+    {
+        switch (node)
+        {
+            case XmlElement { Name: "bindings" } bindings:
+            {
+                foreach (var child in bindings.ChildNodes.Cast<XmlNode>())
+                {
+                    if (child is null) continue;
+                    Visit(child);
+                }
+                break;
+            }
+            default:
+            {
+                throw new NotImplementedException();
+            }
+        }
+    }
+}

tests/Silk.NET.SilkTouch.Emitter.Tests/EmitterFieldTests.cs

@@ -29,7 +29,7 @@ public void FieldIsPublic()
         (
             new FieldSymbol
             (
-                new StructSymbol(new IdentifierSymbol("int"), ImmutableArray<MemberSymbol>.Empty),
+                new StructSymbol(new IdentifierSymbol("int"), StructLayout.Empty),
                 new IdentifierSymbol("Test")
             )
         ) as FieldDeclarationSyntax;
@@ -45,7 +45,7 @@ public void FieldHasCorrectTypeIdentifier()
         (
             new FieldSymbol
             (
-                new StructSymbol(new IdentifierSymbol("int"), ImmutableArray<MemberSymbol>.Empty),
+                new StructSymbol(new IdentifierSymbol("int"), StructLayout.Empty),
                 new IdentifierSymbol("Test")
             )
         ) as FieldDeclarationSyntax;
@@ -63,7 +63,7 @@ public void FieldHasCorrectIdentifier()
         (
             new FieldSymbol
             (
-                new StructSymbol(new IdentifierSymbol("int"), ImmutableArray<MemberSymbol>.Empty),
+                new StructSymbol(new IdentifierSymbol("int"), StructLayout.Empty),
                 new IdentifierSymbol("Test")
             )
         ) as FieldDeclarationSyntax;

tests/Silk.NET.SilkTouch.Scraper.Tests/BasicXMLTests.cs

@@ -0,0 +1,140 @@
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Runtime.Loader;
+using System.Xml;
+using Xunit;
+
+namespace Silk.NET.SilkTouch.Scraper.Tests;
+
+public class BasicXMLTests
+{
+    /*
+     * NOTE:
+     * MOST OF THE FUNCTIONALITY TESTED HERE REALLY DEPENDS ON CLANG(SHARP).
+     * THEREFORE IT IS UNNECESSARY TO TEST IT AS DETAILED AS OTHER PARTS OF THIS SYSTEM.
+     * ONLY CREATE TESTS HERE IF THERE IS AN ISSUE IN OUR SYSTEM THAT YOU NEED TO TRACK DOWN
+     * DO NOT JUST CREATE TESTS TO TEST CLANGSHARP.
+     * IF THERE ARE ISSUES WITH THE XML NOT REFLECTING PART OF A HEADER:
+     * 1. CHECK OUR CONFIGURATION. ITS FAIRLY SIMPLE AND BAREBONES.
+     * 2. IF 1. DID NOT RESOLVE THE PROBLEM, RAISE WITH CLANGSHARP/CLANG INSTEAD.
+     * WE DO NOT WANT TO REWRITE THE XML IN ANY WAY.
+     */
+
+
+    private const string TempFileHeader = @"/* This file is temporarily created for use by Silk.NET tests. If you don't intend to run such a test, feel free to delete this file. */";
+
+
+    [Fact]
+    public void BasicStructScrapingTest()
+    {
+        var tempFile = Path.GetTempFileName();
+
+        File.WriteAllText(tempFile, TempFileHeader + @"
+#include <stdint.h>
+
+typedef struct {
+    int32_t f1;
+    int32_t f2;
+} Test;");
+
+        var scraper = new ClangScraper();
+        var xml = scraper.GenerateXML
+            (tempFile, Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>());
+
+        /*
+         Next, Assert the XML looks something like this:
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<bindings>
+    <namespace name="<PLACEHOLDER>">
+        <struct name="Test">
+            <field name="f1">
+                <type native="int32_t">int</type>
+            </field>
+            <field name="f2">
+                <type native="int32_t">int</type>
+            </field>
+        </struct>
+        </namespace>
+</bindings>
+         */
+
+        Assert.NotNull(xml);
+        // Root
+        Assert.Collection(xml!.ChildNodes.Cast<XmlNode>(), 
+            static dec => Assert.IsType<XmlDeclaration>(dec), // Top Declaration 
+            static bindings => // Root Bindings Element
+            {
+                var e = Assert.IsType<XmlElement>(bindings);
+                Assert.Equal("bindings", e.LocalName);
+                Assert.Collection(e.ChildNodes.Cast<XmlNode>(), // namespaces
+                    static @namespace =>
+                {
+                    var e = Assert.IsType<XmlElement>(@namespace);
+                    var nameAtt = e.Attributes["name"];
+                    Assert.NotNull(nameAtt);
+                    Assert.Equal(ClangScraper.LibraryNamespacePlaceholder, nameAtt!.Value);
+
+                    Assert.Collection(e.ChildNodes.Cast<XmlNode>(), // namespace members 
+                        static @struct =>
+                    {
+                        var e = Assert.IsType<XmlElement>(@struct);
+                        var nameAtt = e.Attributes["name"];
+                        Assert.NotNull(nameAtt);
+                        Assert.Equal("Test", nameAtt!.Value);
+
+                        Assert.Collection(e.ChildNodes.Cast<XmlNode>(), // struct members
+                            static field =>
+                        {
+                            var e = Assert.IsType<XmlElement>(field);
+                            var nameAtt = e.Attributes["name"];
+                            Assert.NotNull(nameAtt);
+                            Assert.Equal("f1", nameAtt!.Value);
+
+                            Assert.Collection(e.ChildNodes.Cast<XmlNode>(), // field infos 
+                                static type =>
+                            {
+                                var e = Assert.IsType<XmlElement>(type);
+                                var nativeAtt = e.Attributes["native"];
+                                Assert.NotNull(nativeAtt);
+                                Assert.Equal("int32_t", nativeAtt!.Value);
+
+                                Assert.Collection(e.ChildNodes.Cast<XmlNode>(), // unwrap converted type
+                                    static type =>
+                                {
+                                    var e = Assert.IsType<XmlText>(type);
+                                    Assert.Equal("int", e.Value);
+                                });
+                            });
+                        }, static field =>
+                        {
+                            var e = Assert.IsType<XmlElement>(field);
+                            var nameAtt = e.Attributes["name"];
+                            Assert.NotNull(nameAtt);
+                            Assert.Equal("f2", nameAtt!.Value);
+
+                            Assert.Collection(e.ChildNodes.Cast<XmlNode>(), // field infos
+                                static type =>
+                            {
+                                var e = Assert.IsType<XmlElement>(type);
+                                var nativeAtt = e.Attributes["native"];
+                                Assert.NotNull(nativeAtt);
+                                Assert.Equal("int32_t", nativeAtt!.Value);
+
+                                Assert.Collection(e.ChildNodes.Cast<XmlNode>(), // unwrap converted type
+                                    static type =>
+                                {
+                                    var e = Assert.IsType<XmlText>(type);
+                                    Assert.Equal("int", e.Value);
+                                });
+                            });
+                        });
+                    });
+                });
+            });
+    }
+}

tests/Silk.NET.SilkTouch.Scraper.Tests/IdentityScrapingTests.cs

@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Linq;
+using System.Xml;
+using Xunit;
+
+namespace Silk.NET.SilkTouch.Scraper.Tests;
+
+public class IdentityScrapingTests
+{
+    [Fact]
+    public void EmptyXmlGeneratesNoSymbols()
+    {
+        var doc = new XmlDocument();
+
+        var symbols = new ClangScraper().ScrapeXML(doc);
+
+        Assert.Empty(symbols);
+    }
+
+    [Fact]
+    public void EmptyBindingsXmlGeneratesNoSymbols()
+    {
+        var doc = new XmlDocument();
+        doc.LoadXml(@"<bindings>
+</bindings>
+");
+
+        var symbols = new ClangScraper().ScrapeXML(doc);
+
+        Assert.Empty(symbols);
+    }
+}
+