Abstract away output mechanisms & add support for XML dumps

.gitignore

@@ -19,3 +19,9 @@ obj/
 ###############################################################################
 .vs/
 *.csproj.user
+
+###############################################################################
+# Rider
+###############################################################################
+.idea/
+*.DotSettings.user

sources/ClangSharp.PInvokeGenerator/Abstractions/ConstantDesc.cs

@@ -0,0 +1,11 @@
+namespace ClangSharp.Abstractions
+{
+    internal struct ConstantDesc
+    {
+        public string AccessSpecifier { get; set; }
+        public string TypeName { get; set; }
+        public string EscapedName { get; set; }
+        public string NativeTypeName { get; set; }
+        public ConstantKind Kind { get; set; }
+    }
+}

sources/ClangSharp.PInvokeGenerator/Abstractions/ConstantKind.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace ClangSharp.Abstractions
+{
+    [Flags]
+    internal enum ConstantKind
+    {
+        None = 0,
+        ReadOnly = 1 << 0,
+        Enumerator = 1 << 1,
+        PrimitiveConstant = 1 << 2,
+        NonPrimitiveConstant = 1 << 3
+    }
+}

sources/ClangSharp.PInvokeGenerator/Abstractions/FieldDesc.cs

@@ -0,0 +1,12 @@
+namespace ClangSharp.Abstractions
+{
+    internal struct FieldDesc
+    {
+        public string AccessSpecifier { get; set; }
+        public string NativeTypeName { get; set; }
+        public string EscapedName { get; set; }
+        public int? Offset { get; set; }
+        public bool NeedsNewKeyword { get; set; }
+        public string InheritedFrom { get; set; }
+    }
+}

sources/ClangSharp.PInvokeGenerator/Abstractions/FunctionOrDelegateDesc.cs

@@ -0,0 +1,114 @@
+using System;
+
+namespace ClangSharp.Abstractions
+{
+    internal struct FunctionOrDelegateDesc<TCustomAttrGeneratorData>
+    {
+        public string AccessSpecifier { get; set; }
+        public string NativeTypeName { get; set; }
+        public string EscapedName { get; set; }
+        public string EntryPoint { get; set; }
+        public string CallingConventionName { get; set; }
+        public string LibraryPath { get; set; }
+        public FunctionOrDelegateFlags Flags { get; set; }
+
+        public bool IsVirtual
+        {
+            get => (Flags & FunctionOrDelegateFlags.IsVirtual) != 0;
+            set => Flags =
+                value ? Flags | FunctionOrDelegateFlags.IsVirtual : Flags & FunctionOrDelegateFlags.IsVirtual;
+        }
+
+        public bool IsDllImport
+        {
+            get => (Flags & FunctionOrDelegateFlags.IsDllImport) != 0;
+            set => Flags = value
+                ? Flags | FunctionOrDelegateFlags.IsDllImport
+                : Flags & FunctionOrDelegateFlags.IsDllImport;
+        }
+
+        public bool HasFnPtrCodeGen
+        {
+            get => (Flags & FunctionOrDelegateFlags.HasFnPtrCodeGen) != 0;
+            set => Flags = value
+                ? Flags | FunctionOrDelegateFlags.HasFnPtrCodeGen
+                : Flags & FunctionOrDelegateFlags.HasFnPtrCodeGen;
+        }
+
+        public bool IsAggressivelyInlined
+        {
+            get => (Flags & FunctionOrDelegateFlags.IsAggressivelyInlined) != 0;
+            set => Flags = value
+                ? Flags | FunctionOrDelegateFlags.IsAggressivelyInlined
+                : Flags & FunctionOrDelegateFlags.IsAggressivelyInlined;
+        }
+
+        public bool SetLastError
+        {
+            get => (Flags & FunctionOrDelegateFlags.SetLastError) != 0;
+            set => Flags = value
+                ? Flags | FunctionOrDelegateFlags.SetLastError
+                : Flags & FunctionOrDelegateFlags.SetLastError;
+        }
+
+        public bool IsCxx
+        {
+            get => (Flags & FunctionOrDelegateFlags.IsCxx) != 0;
+            set => Flags = value ? Flags | FunctionOrDelegateFlags.IsCxx : Flags & FunctionOrDelegateFlags.IsCxx;
+        }
+
+        public bool NeedsNewKeyword
+        {
+            get => (Flags & FunctionOrDelegateFlags.NeedsNewKeyword) != 0;
+            set => Flags = value
+                ? Flags | FunctionOrDelegateFlags.NeedsNewKeyword
+                : Flags & FunctionOrDelegateFlags.NeedsNewKeyword;
+        }
+
+        public bool IsUnsafe
+        {
+            get => (Flags & FunctionOrDelegateFlags.IsUnsafe) != 0;
+            set => Flags = value ? Flags | FunctionOrDelegateFlags.IsUnsafe : Flags & FunctionOrDelegateFlags.IsUnsafe;
+        }
+
+        public bool IsCtxCxxRecord
+        {
+            get => (Flags & FunctionOrDelegateFlags.IsCtxCxxRecord) != 0;
+            set => Flags = value
+                ? Flags | FunctionOrDelegateFlags.IsCtxCxxRecord
+                : Flags & FunctionOrDelegateFlags.IsCtxCxxRecord;
+        }
+
+        public bool IsCxxRecordCtxUnsafe
+        {
+            get => (Flags & FunctionOrDelegateFlags.IsCxxRecordCtxUnsafe) != 0;
+            set => Flags = value
+                ? Flags | FunctionOrDelegateFlags.IsCxxRecordCtxUnsafe
+                : Flags & FunctionOrDelegateFlags.IsCxxRecordCtxUnsafe;
+        }
+
+        public bool IsMemberFunction
+        {
+            get => (Flags & FunctionOrDelegateFlags.IsMemberFunction) != 0;
+            set => Flags = value
+                ? Flags | FunctionOrDelegateFlags.IsMemberFunction
+                : Flags & FunctionOrDelegateFlags.IsMemberFunction;
+        }
+
+        public bool? IsStatic
+        {
+            get => (Flags & FunctionOrDelegateFlags.IsStatic) != 0 ? true :
+                (Flags & FunctionOrDelegateFlags.IsNotStatic) != 0 ? false : null;
+            set => Flags = value switch
+            {
+                // true - static, false - not static, null - infer
+                true => Flags | FunctionOrDelegateFlags.IsStatic & FunctionOrDelegateFlags.IsNotStatic,
+                false => Flags & FunctionOrDelegateFlags.IsStatic | FunctionOrDelegateFlags.IsNotStatic,
+                null => Flags & FunctionOrDelegateFlags.IsStatic & FunctionOrDelegateFlags.IsNotStatic
+            };
+        }
+
+        public Action<TCustomAttrGeneratorData> WriteCustomAttrs { get; set; }
+        public TCustomAttrGeneratorData CustomAttrGeneratorData { get; set; }
+    }
+}

sources/ClangSharp.PInvokeGenerator/Abstractions/IOutputBuilder.Visit.cs

@@ -0,0 +1,12 @@
+namespace ClangSharp.Abstractions
+{
+    internal partial interface IOutputBuilder
+    {
+        void WriteDivider(bool force = false);
+        void SuppressDivider();
+
+        void WriteCustomAttribute(string attribute);
+        void WriteIid(string iidName, string iidValue);
+        void EmitUsingDirective(string directive);
+    }
+}

sources/ClangSharp.PInvokeGenerator/Abstractions/IOutputBuilder.VisitDecl.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using ClangSharp.CSharp;
+
+namespace ClangSharp.Abstractions
+{
+    internal partial interface IOutputBuilder
+    {
+        void BeginInnerValue();
+        void EndInnerValue();
+
+        void BeginInnerCast();
+        void WriteCastType(string targetTypeName);
+        void EndInnerCast();
+
+        void BeginUnchecked();
+        void EndUnchecked();
+
+        void BeginConstant(in ConstantDesc desc);
+        void BeginConstantValue(bool isGetOnlyProperty = false);
+        void WriteConstantValue(long value);
+        void WriteConstantValue(ulong value);
+        void EndConstantValue();
+        void EndConstant(bool isConstant);
+
+        void BeginEnum(string accessSpecifier, string typeName, string escapedName, string nativeTypeName);
+        void EndEnum();
+
+        void BeginField(in FieldDesc desc);
+        void WriteFixedCountField(string typeName, string escapedName, string fixedName, string count);
+        void WriteRegularField(string typeName, string escapedName);
+        void EndField(bool isBodyless = true);
+
+        void BeginFunctionOrDelegate<TCustomAttrGeneratorData>(in FunctionOrDelegateDesc<TCustomAttrGeneratorData> info,
+            ref bool isMethodClassUnsafe);
+        void WriteReturnType(string typeString);
+        void BeginFunctionInnerPrototype(string escapedName);
+        void BeginParameter<TCustomAttrGeneratorData>(in ParameterDesc<TCustomAttrGeneratorData> info);
+        void BeginParameterDefault();
+        void EndParameterDefault();
+        void EndParameter();
+        void WriteParameterSeparator();
+        void EndFunctionInnerPrototype();
+        void BeginConstructorInitializer(string memberRefName, string memberInitName);
+        void EndConstructorInitializer();
+        void BeginBody(bool isExpressionBody = false);
+        void BeginConstructorInitializers();
+        void EndConstructorInitializers();
+        void BeginInnerFunctionBody();
+        void EndInnerFunctionBody();
+        void EndBody(bool isExpressionBody = false);
+        void EndFunctionOrDelegate(bool isVirtual, bool isBodyless);
+
+        void BeginStruct<TCustomAttrGeneratorData>(in StructDesc<TCustomAttrGeneratorData> info);
+        void BeginExplicitVtbl();
+        void EndExplicitVtbl();
+        void EndStruct();
+
+        void EmitCompatibleCodeSupport();
+        void EmitFnPtrSupport();
+        void EmitSystemSupport();
+
+        CSharpOutputBuilder BeginCSharpCode();
+        void EndCSharpCode(CSharpOutputBuilder output);
+
+        void BeginGetter(bool aggressivelyInlined);
+        void EndGetter();
+        void BeginSetter(bool aggressivelyInlined);
+        void EndSetter();
+
+        void BeginIndexer(string accessSpecifier, bool isUnsafe);
+        void WriteIndexer(string typeName);
+        void BeginIndexerParameters();
+        void EndIndexerParameters();
+        void EndIndexer();
+
+        void BeginDereference();
+        void EndDereference();
+    }
+}

sources/ClangSharp.PInvokeGenerator/Abstractions/IOutputBuilder.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace ClangSharp.Abstractions
+{
+    internal partial interface IOutputBuilder
+    {
+        bool IsTestOutput { get; }
+        string Name { get; }
+        string Extension { get; }
+    }
+}

sources/ClangSharp.PInvokeGenerator/Abstractions/ParameterDesc.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+
+namespace ClangSharp.Abstractions
+{
+    internal struct ParameterDesc<TCustomAttrGeneratorData>
+    {
+        public string Type { get; set; }
+        public string Name { get; set; }
+        public string NativeTypeName { get; set; }
+        public IEnumerable<string> CppAttributes { get; set; }
+        public Action<TCustomAttrGeneratorData> WriteCustomAttrs { get; set; }
+        public TCustomAttrGeneratorData CustomAttrGeneratorData { get; set; }
+    }
+}

sources/ClangSharp.PInvokeGenerator/Abstractions/StructDesc.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace ClangSharp.Abstractions
+{
+    internal struct StructDesc<TCustomAttrGeneratorData>
+    {
+        public string AccessSpecifier { get; set; }
+        public string EscapedName { get; set; }
+        public string NativeType { get; set; }
+        public string NativeInheritance { get; set; }
+        public StructLayoutAttribute Layout { get; set; }
+        public Guid? Uuid { get; set; }
+        public StructFlags Flags { get; set; }
+
+        public bool IsUnsafe
+        {
+            get => (Flags & StructFlags.IsUnsafe) != 0;
+            set => Flags = value ? Flags | StructFlags.IsUnsafe : Flags ^ StructFlags.IsUnsafe;
+        }
+
+        public bool HasVtbl
+        {
+            get => (Flags & StructFlags.HasVtbl) != 0;
+            set => Flags = value ? Flags | StructFlags.HasVtbl : Flags ^ StructFlags.HasVtbl;
+        }
+
+        public Action<TCustomAttrGeneratorData> WriteCustomAttrs { get; set; }
+        public TCustomAttrGeneratorData CustomAttrGeneratorData { get; set; }
+    }
+}

sources/ClangSharp.PInvokeGenerator/Abstractions/StructFlags.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace ClangSharp.Abstractions
+{
+    [Flags]
+    public enum StructFlags
+    {
+        IsUnsafe = 1 << 0,
+        HasVtbl = 1 << 1
+    }
+}

sources/ClangSharp.PInvokeGenerator/CSharp/CSharpOutputBuilder.Visit.cs

@@ -0,0 +1,67 @@
+namespace ClangSharp.CSharp
+{
+    internal partial class CSharpOutputBuilder
+    {
+        private bool _customAttrIsForParameter = false;
+        public void WriteCustomAttribute(string attribute)
+        {
+            if (attribute.Equals("Flags") || attribute.Equals("Obsolete"))
+            {
+                AddUsingDirective("System");
+            }
+            else if (attribute.Equals("EditorBrowsable") || attribute.StartsWith("EditorBrowsable("))
+            {
+                AddUsingDirective("System.ComponentModel");
+            }
+            else if (attribute.StartsWith("Guid("))
+            {
+                AddUsingDirective("System.Runtime.InteropServices");
+            }
+
+            if (!_customAttrIsForParameter)
+            {
+                WriteIndented('[');
+                Write(attribute);
+                WriteLine(']');
+            }
+            else
+            {
+                Write('[');
+                Write(attribute);
+                Write(']');
+                Write(' ');
+            }
+        }
+
+        public void WriteDivider(bool force = false)
+        {
+            if (force)
+            {
+                WriteNewline();
+            }
+            else
+            {
+                NeedsNewline = true;
+            }
+        }
+
+        public void SuppressDivider()
+        {
+            NeedsNewline = false;
+        }
+
+        public void WriteIid(string iidName, string iidValue)
+        {
+            AddUsingDirective("System");
+            WriteIndented("public static readonly Guid ");
+            Write(iidName);
+            Write(" = new Guid(");
+            Write(iidValue);
+            Write(")");
+            WriteSemicolon();
+            WriteNewline();
+        }
+
+        public void EmitUsingDirective(string directive) => AddUsingDirective(directive);
+    }
+}