Fix C# bindings after recent breaking changes

Implementation for new Variant types Callable, Signal, StringName.
Added support for PackedInt64Array and PackedFloat64Array.

Add generation of signal members as events, as well as support for
user created signals as events.
NOTE: As of now, raising such events will not emit the signal. As such,
one must use `EmitSignal` instead of raising the event directly.

Removed old ThreadLocal fallback class. It's safe to use thread_local now since
it's supported on all minimum versions of compilers we support.

17 files changed, 751 insertions, 83 deletions

diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/SignalAttribute.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/SignalAttribute.cs
index 3957387be9..39d5782db8 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/SignalAttribute.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/SignalAttribute.cs
@@ -2,7 +2,7 @@ using System;
 
 namespace Godot
 {
-    [AttributeUsage(AttributeTargets.Delegate)]
+    [AttributeUsage(AttributeTargets.Delegate | AttributeTargets.Event)]
     public class SignalAttribute : Attribute
     {
     }
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Callable.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Callable.cs
new file mode 100644
index 0000000000..c85cc1884c
--- /dev/null
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Callable.cs
@@ -0,0 +1,31 @@
+using System;
+
+namespace Godot
+{
+    public struct Callable
+    {
+        private readonly Object _target;
+        private readonly StringName _method;
+        private readonly Delegate _delegate;
+
+        public Object Target => _target;
+        public StringName Method => _method;
+        public Delegate Delegate => _delegate;
+
+        public static implicit operator Callable(Delegate @delegate) => new Callable(@delegate);
+
+        public Callable(Object target, StringName method)
+        {
+            _target = target;
+            _method = method;
+            _delegate = null;
+        }
+
+        public Callable(Delegate @delegate)
+        {
+            _target = null;
+            _method = null;
+            _delegate = @delegate;
+        }
+    }
+}
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/DelegateUtils.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/DelegateUtils.cs
new file mode 100644
index 0000000000..785e87a043
--- /dev/null
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/DelegateUtils.cs
@@ -0,0 +1,395 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace Godot
+{
+    internal static class DelegateUtils
+    {
+        private enum TargetKind : uint
+        {
+            Static,
+            GodotObject,
+            CompilerGenerated
+        }
+
+        internal static bool TrySerializeDelegate(Delegate @delegate, Collections.Array serializedData)
+        {
+            if (@delegate is MulticastDelegate multicastDelegate)
+            {
+                bool someDelegatesSerialized = false;
+
+                Delegate[] invocationList = multicastDelegate.GetInvocationList();
+
+                if (invocationList.Length > 1)
+                {
+                    var multiCastData = new Collections.Array();
+
+                    foreach (Delegate oneDelegate in invocationList)
+                        someDelegatesSerialized |= TrySerializeDelegate(oneDelegate, multiCastData);
+
+                    if (!someDelegatesSerialized)
+                        return false;
+
+                    serializedData.Add(multiCastData);
+                    return true;
+                }
+            }
+
+            if (TrySerializeSingleDelegate(@delegate, out byte[] buffer))
+            {
+                serializedData.Add(buffer);
+                return true;
+            }
+
+            return false;
+        }
+
+        private static bool TrySerializeSingleDelegate(Delegate @delegate, out byte[] buffer)
+        {
+            buffer = null;
+
+            object target = @delegate.Target;
+
+            switch (target)
+            {
+                case null:
+                {
+                    using (var stream = new MemoryStream())
+                    using (var writer = new BinaryWriter(stream))
+                    {
+                        writer.Write((ulong) TargetKind.Static);
+
+                        SerializeType(writer, @delegate.GetType());
+
+                        if (!TrySerializeMethodInfo(writer, @delegate.Method))
+                            return false;
+
+                        buffer = stream.ToArray();
+                        return true;
+                    }
+                }
+                case Godot.Object godotObject:
+                {
+                    using (var stream = new MemoryStream())
+                    using (var writer = new BinaryWriter(stream))
+                    {
+                        writer.Write((ulong) TargetKind.GodotObject);
+                        writer.Write((ulong) godotObject.GetInstanceId());
+
+                        SerializeType(writer, @delegate.GetType());
+
+                        if (!TrySerializeMethodInfo(writer, @delegate.Method))
+                            return false;
+
+                        buffer = stream.ToArray();
+                        return true;
+                    }
+                }
+                default:
+                {
+                    Type targetType = target.GetType();
+
+                    if (targetType.GetCustomAttribute(typeof(CompilerGeneratedAttribute), true) != null)
+                    {
+                        // Compiler generated. Probably a closure. Try to serialize it.
+
+                        using (var stream = new MemoryStream())
+                        using (var writer = new BinaryWriter(stream))
+                        {
+                            writer.Write((ulong) TargetKind.CompilerGenerated);
+                            SerializeType(writer, targetType);
+
+                            SerializeType(writer, @delegate.GetType());
+
+                            if (!TrySerializeMethodInfo(writer, @delegate.Method))
+                                return false;
+
+                            FieldInfo[] fields = targetType.GetFields(BindingFlags.Instance | BindingFlags.Public);
+
+                            writer.Write(fields.Length);
+
+                            foreach (FieldInfo field in fields)
+                            {
+                                Type fieldType = field.GetType();
+
+                                Variant.Type variantType = GD.TypeToVariantType(fieldType);
+
+                                if (variantType == Variant.Type.Nil)
+                                    return false;
+
+                                writer.Write(field.Name);
+                                byte[] valueBuffer = GD.Var2Bytes(field.GetValue(target));
+                                writer.Write(valueBuffer.Length);
+                                writer.Write(valueBuffer);
+                            }
+
+                            buffer = stream.ToArray();
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+            }
+        }
+
+        private static bool TrySerializeMethodInfo(BinaryWriter writer, MethodInfo methodInfo)
+        {
+            if (methodInfo == null)
+                return false;
+
+            SerializeType(writer, methodInfo.DeclaringType);
+
+            writer.Write(methodInfo.Name);
+
+            int flags = 0;
+
+            if (methodInfo.IsPublic)
+                flags |= (int) BindingFlags.Public;
+            else
+                flags |= (int) BindingFlags.NonPublic;
+
+            if (methodInfo.IsStatic)
+                flags |= (int) BindingFlags.Static;
+            else
+                flags |= (int) BindingFlags.Instance;
+
+            writer.Write(flags);
+
+            Type returnType = methodInfo.ReturnType;
+            bool hasReturn = methodInfo.ReturnType != typeof(void);
+
+            writer.Write(hasReturn);
+            if (hasReturn)
+                SerializeType(writer, returnType);
+
+            ParameterInfo[] parameters = methodInfo.GetParameters();
+
+            writer.Write(parameters.Length);
+
+            if (parameters.Length > 0)
+            {
+                for (int i = 0; i < parameters.Length; i++)
+                    SerializeType(writer, parameters[i].ParameterType);
+            }
+
+            return true;
+        }
+
+        private static void SerializeType(BinaryWriter writer, Type type)
+        {
+            if (type == null)
+            {
+                int genericArgumentsCount = -1;
+                writer.Write(genericArgumentsCount);
+            }
+            else if (type.IsGenericType)
+            {
+                Type genericTypeDef = type.GetGenericTypeDefinition();
+                Type[] genericArgs = type.GetGenericArguments();
+
+                int genericArgumentsCount = genericArgs.Length;
+                writer.Write(genericArgumentsCount);
+
+                string assemblyQualifiedName = genericTypeDef.AssemblyQualifiedName;
+                Debug.Assert(assemblyQualifiedName != null);
+                writer.Write(assemblyQualifiedName);
+
+                for (int i = 0; i < genericArgs.Length; i++)
+                    SerializeType(writer, genericArgs[i]);
+            }
+            else
+            {
+                int genericArgumentsCount = 0;
+                writer.Write(genericArgumentsCount);
+
+                string assemblyQualifiedName = type.AssemblyQualifiedName;
+                Debug.Assert(assemblyQualifiedName != null);
+                writer.Write(assemblyQualifiedName);
+            }
+        }
+
+        private static bool TryDeserializeDelegate(Collections.Array serializedData, out Delegate @delegate)
+        {
+            if (serializedData.Count == 1)
+            {
+                object elem = serializedData[0];
+
+                if (elem is Collections.Array multiCastData)
+                    return TryDeserializeDelegate(multiCastData, out @delegate);
+
+                return TryDeserializeSingleDelegate((byte[])elem, out @delegate);
+            }
+
+            @delegate = null;
+
+            var delegates = new List<Delegate>(serializedData.Count);
+
+            foreach (object elem in serializedData)
+            {
+                if (elem is Collections.Array multiCastData)
+                {
+                    if (TryDeserializeDelegate(multiCastData, out Delegate oneDelegate))
+                        delegates.Add(oneDelegate);
+                }
+                else
+                {
+                    if (TryDeserializeSingleDelegate((byte[]) elem, out Delegate oneDelegate))
+                        delegates.Add(oneDelegate);
+                }
+            }
+
+            if (delegates.Count <= 0)
+                return false;
+
+            @delegate = delegates.Count == 1 ? delegates[0] : Delegate.Combine(delegates.ToArray());
+            return true;
+        }
+
+        private static bool TryDeserializeSingleDelegate(byte[] buffer, out Delegate @delegate)
+        {
+            @delegate = null;
+
+            using (var stream = new MemoryStream(buffer, writable: false))
+            using (var reader = new BinaryReader(stream))
+            {
+                var targetKind = (TargetKind) reader.ReadUInt64();
+
+                switch (targetKind)
+                {
+                    case TargetKind.Static:
+                    {
+                        Type delegateType = DeserializeType(reader);
+                        if (delegateType == null)
+                            return false;
+
+                        if (!TryDeserializeMethodInfo(reader, out MethodInfo methodInfo))
+                            return false;
+
+                        @delegate = Delegate.CreateDelegate(delegateType, null, methodInfo);
+                        return true;
+                    }
+                    case TargetKind.GodotObject:
+                    {
+                        ulong objectId = reader.ReadUInt64();
+                        Godot.Object godotObject = GD.InstanceFromId(objectId);
+                        if (godotObject == null)
+                            return false;
+
+                        Type delegateType = DeserializeType(reader);
+                        if (delegateType == null)
+                            return false;
+
+                        if (!TryDeserializeMethodInfo(reader, out MethodInfo methodInfo))
+                            return false;
+
+                        @delegate = Delegate.CreateDelegate(delegateType, godotObject, methodInfo);
+                        return true;
+                    }
+                    case TargetKind.CompilerGenerated:
+                    {
+                        Type targetType = DeserializeType(reader);
+                        if (targetType == null)
+                            return false;
+
+                        Type delegateType = DeserializeType(reader);
+                        if (delegateType == null)
+                            return false;
+
+                        if (!TryDeserializeMethodInfo(reader, out MethodInfo methodInfo))
+                            return false;
+
+                        int fieldCount = reader.ReadInt32();
+
+                        object recreatedTarget = Activator.CreateInstance(targetType);
+
+                        for (int i = 0; i < fieldCount; i++)
+                        {
+                            string name = reader.ReadString();
+                            int valueBufferLength = reader.ReadInt32();
+                            byte[] valueBuffer = reader.ReadBytes(valueBufferLength);
+
+                            FieldInfo fieldInfo = targetType.GetField(name, BindingFlags.Instance | BindingFlags.Public);
+                            fieldInfo?.SetValue(recreatedTarget, GD.Bytes2Var(valueBuffer));
+                        }
+
+                        @delegate = Delegate.CreateDelegate(delegateType, recreatedTarget, methodInfo);
+                        return true;
+                    }
+                    default:
+                        return false;
+                }
+            }
+        }
+
+        private static bool TryDeserializeMethodInfo(BinaryReader reader, out MethodInfo methodInfo)
+        {
+            methodInfo = null;
+
+            Type declaringType = DeserializeType(reader);
+
+            string methodName = reader.ReadString();
+
+            int flags = reader.ReadInt32();
+
+            bool hasReturn = reader.ReadBoolean();
+            Type returnType = hasReturn ? DeserializeType(reader) : typeof(void);
+
+            int parametersCount = reader.ReadInt32();
+
+            if (parametersCount > 0)
+            {
+                var parameterTypes = new Type[parametersCount];
+
+                for (int i = 0; i < parametersCount; i++)
+                {
+                    Type parameterType = DeserializeType(reader);
+                    if (parameterType == null)
+                        return false;
+                    parameterTypes[i] = parameterType;
+                }
+
+                methodInfo = declaringType.GetMethod(methodName, (BindingFlags) flags, null, parameterTypes, null);
+                return methodInfo != null && methodInfo.ReturnType == returnType;
+            }
+
+            methodInfo = declaringType.GetMethod(methodName, (BindingFlags) flags);
+            return methodInfo != null && methodInfo.ReturnType == returnType;
+        }
+
+        private static Type DeserializeType(BinaryReader reader)
+        {
+            int genericArgumentsCount = reader.ReadInt32();
+
+            if (genericArgumentsCount == -1)
+                return null;
+
+            string assemblyQualifiedName = reader.ReadString();
+            var type = Type.GetType(assemblyQualifiedName);
+
+            if (type == null)
+                return null; // Type not found
+
+            if (genericArgumentsCount != 0)
+            {
+                var genericArgumentTypes = new Type[genericArgumentsCount];
+
+                for (int i = 0; i < genericArgumentsCount; i++)
+                {
+                    Type genericArgumentType = DeserializeType(reader);
+                    if (genericArgumentType == null)
+                        return null;
+                    genericArgumentTypes[i] = genericArgumentType;
+                }
+
+                type = type.MakeGenericType(genericArgumentTypes);
+            }
+
+            return type;
+        }
+    }
+}
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/GD.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/GD.cs
index 2a9c2d73b1..9384da0e48 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/GD.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/GD.cs
@@ -5,6 +5,7 @@ using System.Runtime.CompilerServices;
 using real_t = System.Double;
 #else
 using real_t = System.Single;
+
 #endif
 
 // TODO: Add comments describing what this class does. It is not obvious.
@@ -13,9 +14,9 @@ namespace Godot
 {
     public static partial class GD
     {
-        public static object Bytes2Var(byte[] bytes, bool allow_objects = false)
+        public static object Bytes2Var(byte[] bytes, bool allowObjects = false)
         {
-            return godot_icall_GD_bytes2var(bytes, allow_objects);
+            return godot_icall_GD_bytes2var(bytes, allowObjects);
         }
 
         public static object Convert(object what, Variant.Type type)
@@ -25,7 +26,7 @@ namespace Godot
 
         public static real_t Db2Linear(real_t db)
         {
-            return (real_t)Math.Exp(db * 0.11512925464970228420089957273422);
+            return (real_t) Math.Exp(db * 0.11512925464970228420089957273422);
         }
 
         public static real_t DecTime(real_t value, real_t amount, real_t step)
@@ -38,11 +39,11 @@ namespace Godot
             return val * sgn;
         }
 
-        public static FuncRef FuncRef(Object instance, string funcname)
+        public static FuncRef FuncRef(Object instance, StringName funcName)
         {
             var ret = new FuncRef();
             ret.SetInstance(instance);
-            ret.SetFunction(funcname);
+            ret.SetFunction(funcName);
             return ret;
         }
 
@@ -58,7 +59,7 @@ namespace Godot
 
         public static real_t Linear2Db(real_t linear)
         {
-            return (real_t)(Math.Log(linear) * 8.6858896380650365530225783783321);
+            return (real_t) (Math.Log(linear) * 8.6858896380650365530225783783321);
         }
 
         public static Resource Load(string path)
@@ -181,14 +182,14 @@ namespace Godot
             return godot_icall_GD_str2var(str);
         }
 
-        public static bool TypeExists(string type)
+        public static bool TypeExists(StringName type)
         {
-            return godot_icall_GD_type_exists(type);
+            return godot_icall_GD_type_exists(StringName.GetPtr(type));
         }
 
-        public static byte[] Var2Bytes(object var, bool full_objects = false)
+        public static byte[] Var2Bytes(object var, bool fullObjects = false)
         {
-            return godot_icall_GD_var2bytes(var, full_objects);
+            return godot_icall_GD_var2bytes(var, fullObjects);
         }
 
         public static string Var2Str(object var)
@@ -196,8 +197,13 @@ namespace Godot
             return godot_icall_GD_var2str(var);
         }
 
+        public static Variant.Type TypeToVariantType(Type type)
+        {
+            return godot_icall_TypeToVariantType(type);
+        }
+
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static object godot_icall_GD_bytes2var(byte[] bytes, bool allow_objects);
+        internal extern static object godot_icall_GD_bytes2var(byte[] bytes, bool allowObjects);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal extern static object godot_icall_GD_convert(object what, Variant.Type type);
@@ -206,7 +212,7 @@ namespace Godot
         internal extern static int godot_icall_GD_hash(object var);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static Object godot_icall_GD_instance_from_id(ulong instance_id);
+        internal extern static Object godot_icall_GD_instance_from_id(ulong instanceId);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal extern static void godot_icall_GD_print(object[] what);
@@ -249,10 +255,10 @@ namespace Godot
         internal extern static object godot_icall_GD_str2var(string str);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static bool godot_icall_GD_type_exists(string type);
+        internal extern static bool godot_icall_GD_type_exists(IntPtr type);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static byte[] godot_icall_GD_var2bytes(object what, bool full_objects);
+        internal extern static byte[] godot_icall_GD_var2bytes(object what, bool fullObjects);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal extern static string godot_icall_GD_var2str(object var);
@@ -262,5 +268,8 @@ namespace Godot
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal extern static void godot_icall_GD_pushwarning(string type);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Variant.Type godot_icall_TypeToVariantType(Type type);
     }
 }
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/NodePath.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/NodePath.cs
index 8c5872ba5a..4ecc55f94e 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/NodePath.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/NodePath.cs
@@ -7,7 +7,7 @@ namespace Godot
     {
         private bool disposed = false;
 
-        internal IntPtr ptr;
+        private IntPtr ptr;
 
         internal static IntPtr GetPtr(NodePath instance)
         {
@@ -50,104 +50,93 @@ namespace Godot
             this.ptr = ptr;
         }
 
-        public IntPtr NativeInstance
-        {
-            get { return ptr; }
-        }
-
         public NodePath() : this(string.Empty) {}
 
         public NodePath(string path)
         {
-            this.ptr = godot_icall_NodePath_Ctor(path);
+            ptr = godot_icall_NodePath_Ctor(path);
         }
 
-        public static implicit operator NodePath(string from)
-        {
-            return new NodePath(from);
-        }
+        public static implicit operator NodePath(string from) => new NodePath(from);
 
-        public static implicit operator string(NodePath from)
-        {
-            return godot_icall_NodePath_operator_String(NodePath.GetPtr(from));
-        }
+        public static implicit operator string(NodePath from) => from.ToString();
 
         public override string ToString()
         {
-            return (string)this;
+            return godot_icall_NodePath_operator_String(GetPtr(this));
         }
 
         public NodePath GetAsPropertyPath()
         {
-            return new NodePath(godot_icall_NodePath_get_as_property_path(NodePath.GetPtr(this)));
+            return new NodePath(godot_icall_NodePath_get_as_property_path(GetPtr(this)));
         }
 
         public string GetConcatenatedSubnames()
         {
-            return godot_icall_NodePath_get_concatenated_subnames(NodePath.GetPtr(this));
+            return godot_icall_NodePath_get_concatenated_subnames(GetPtr(this));
         }
 
         public string GetName(int idx)
         {
-            return godot_icall_NodePath_get_name(NodePath.GetPtr(this), idx);
+            return godot_icall_NodePath_get_name(GetPtr(this), idx);
         }
 
         public int GetNameCount()
         {
-            return godot_icall_NodePath_get_name_count(NodePath.GetPtr(this));
+            return godot_icall_NodePath_get_name_count(GetPtr(this));
         }
 
         public string GetSubname(int idx)
         {
-            return godot_icall_NodePath_get_subname(NodePath.GetPtr(this), idx);
+            return godot_icall_NodePath_get_subname(GetPtr(this), idx);
         }
 
         public int GetSubnameCount()
         {
-            return godot_icall_NodePath_get_subname_count(NodePath.GetPtr(this));
+            return godot_icall_NodePath_get_subname_count(GetPtr(this));
         }
 
         public bool IsAbsolute()
         {
-            return godot_icall_NodePath_is_absolute(NodePath.GetPtr(this));
+            return godot_icall_NodePath_is_absolute(GetPtr(this));
         }
 
         public bool IsEmpty()
         {
-            return godot_icall_NodePath_is_empty(NodePath.GetPtr(this));
+            return godot_icall_NodePath_is_empty(GetPtr(this));
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static IntPtr godot_icall_NodePath_Ctor(string path);
+        private static extern IntPtr godot_icall_NodePath_Ctor(string path);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_NodePath_Dtor(IntPtr ptr);
+        private static extern void godot_icall_NodePath_Dtor(IntPtr ptr);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static string godot_icall_NodePath_operator_String(IntPtr ptr);
+        private static extern string godot_icall_NodePath_operator_String(IntPtr ptr);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static IntPtr godot_icall_NodePath_get_as_property_path(IntPtr ptr);
+        private static extern IntPtr godot_icall_NodePath_get_as_property_path(IntPtr ptr);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static string godot_icall_NodePath_get_concatenated_subnames(IntPtr ptr);
+        private static extern string godot_icall_NodePath_get_concatenated_subnames(IntPtr ptr);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static string godot_icall_NodePath_get_name(IntPtr ptr, int arg1);
+        private static extern string godot_icall_NodePath_get_name(IntPtr ptr, int arg1);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static int godot_icall_NodePath_get_name_count(IntPtr ptr);
+        private static extern int godot_icall_NodePath_get_name_count(IntPtr ptr);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static string godot_icall_NodePath_get_subname(IntPtr ptr, int arg1);
+        private static extern string godot_icall_NodePath_get_subname(IntPtr ptr, int arg1);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static int godot_icall_NodePath_get_subname_count(IntPtr ptr);
+        private static extern int godot_icall_NodePath_get_subname_count(IntPtr ptr);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static bool godot_icall_NodePath_is_absolute(IntPtr ptr);
+        private static extern bool godot_icall_NodePath_is_absolute(IntPtr ptr);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static bool godot_icall_NodePath_is_empty(IntPtr ptr);
+        private static extern bool godot_icall_NodePath_is_empty(IntPtr ptr);
     }
 }
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Object.base.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Object.base.cs
index de80f7fddc..42610c5ef7 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Object.base.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Object.base.cs
@@ -7,7 +7,7 @@ namespace Godot
     {
         private bool disposed = false;
 
-        private const string nativeName = "Object";
+        private static StringName nativeName = "Object";
 
         internal IntPtr ptr;
         internal bool memoryOwn;
@@ -15,7 +15,14 @@ namespace Godot
         public Object() : this(false)
         {
             if (ptr == IntPtr.Zero)
+            {
                 ptr = godot_icall_Object_Ctor(this);
+            }
+            else
+            {
+                // This is called inside godot_icall_Object_Ctor, so we must call it as well in this case.
+                godot_icall_Object_ConnectEventSignals(ptr);
+            }
         }
 
         internal Object(bool memoryOwn)
@@ -101,7 +108,7 @@ namespace Godot
         /// }
         /// </code>
         /// </example>
-        public SignalAwaiter ToSignal(Object source, string signal)
+        public SignalAwaiter ToSignal(Object source, StringName signal)
         {
             return new SignalAwaiter(source, signal, this);
         }
@@ -111,20 +118,28 @@ namespace Godot
         /// </summary>
         public dynamic DynamicObject => new DynamicGodotObject(this);
 
+        internal static IntPtr __ClassDB_get_method(StringName type, string method)
+        {
+            return godot_icall_Object_ClassDB_get_method(StringName.GetPtr(type), method);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern IntPtr godot_icall_Object_Ctor(Object obj);
+
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static IntPtr godot_icall_Object_Ctor(Object obj);
+        internal static extern void godot_icall_Object_Disposed(Object obj, IntPtr ptr);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_Object_Disposed(Object obj, IntPtr ptr);
+        internal static extern void godot_icall_Reference_Disposed(Object obj, IntPtr ptr, bool isFinalizer);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_Reference_Disposed(Object obj, IntPtr ptr, bool isFinalizer);
+        internal static extern void godot_icall_Object_ConnectEventSignals(IntPtr obj);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static string godot_icall_Object_ToString(IntPtr ptr);
+        internal static extern string godot_icall_Object_ToString(IntPtr ptr);
 
         // Used by the generated API
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static IntPtr godot_icall_Object_ClassDB_get_method(string type, string method);
+        internal static extern IntPtr godot_icall_Object_ClassDB_get_method(IntPtr type, string method);
     }
 }
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/SignalAwaiter.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/SignalAwaiter.cs
index 9483b6ffb4..4dc630238b 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/SignalAwaiter.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/SignalAwaiter.cs
@@ -9,13 +9,13 @@ namespace Godot
         private object[] result;
         private Action action;
 
-        public SignalAwaiter(Object source, string signal, Object target)
+        public SignalAwaiter(Object source, StringName signal, Object target)
         {
-            godot_icall_SignalAwaiter_connect(Object.GetPtr(source), signal, Object.GetPtr(target), this);
+            godot_icall_SignalAwaiter_connect(Object.GetPtr(source), StringName.GetPtr(signal), Object.GetPtr(target), this);
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static Error godot_icall_SignalAwaiter_connect(IntPtr source, string signal, IntPtr target, SignalAwaiter awaiter);
+        internal extern static Error godot_icall_SignalAwaiter_connect(IntPtr source, IntPtr signal, IntPtr target, SignalAwaiter awaiter);
 
         public bool IsCompleted
         {
@@ -50,11 +50,5 @@ namespace Godot
                 action();
             }
         }
-
-        internal void FailureCallback()
-        {
-            action = null;
-            completed = true;
-        }
     }
 }
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/SignalInfo.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/SignalInfo.cs
new file mode 100644
index 0000000000..dc92de7a61
--- /dev/null
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/SignalInfo.cs
@@ -0,0 +1,17 @@
+namespace Godot
+{
+    public struct SignalInfo
+    {
+        private readonly Object _owner;
+        private readonly StringName _signalName;
+
+        public Object Owner => _owner;
+        public StringName Name => _signalName;
+
+        public SignalInfo(Object owner, StringName name)
+        {
+            _owner = owner;
+            _signalName = name;
+        }
+    }
+}
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/StringName.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/StringName.cs
new file mode 100644
index 0000000000..7700b6d4ed
--- /dev/null
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/StringName.cs
@@ -0,0 +1,82 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Godot
+{
+    public sealed partial class StringName : IDisposable
+    {
+        private IntPtr ptr;
+
+        internal static IntPtr GetPtr(StringName instance)
+        {
+            if (instance == null)
+                throw new NullReferenceException($"The instance of type {nameof(StringName)} is null.");
+
+            if (instance.ptr == IntPtr.Zero)
+                throw new ObjectDisposedException(instance.GetType().FullName);
+
+            return instance.ptr;
+        }
+
+        ~StringName()
+        {
+            Dispose(false);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        private void Dispose(bool disposing)
+        {
+            if (ptr != IntPtr.Zero)
+            {
+                godot_icall_StringName_Dtor(ptr);
+                ptr = IntPtr.Zero;
+            }
+        }
+
+        internal StringName(IntPtr ptr)
+        {
+            this.ptr = ptr;
+        }
+
+        public StringName()
+        {
+            ptr = IntPtr.Zero;
+        }
+
+        public StringName(string path)
+        {
+            ptr = path == null ? IntPtr.Zero : godot_icall_StringName_Ctor(path);
+        }
+
+        public static implicit operator StringName(string from) => new StringName(from);
+
+        public static implicit operator string(StringName from) => from.ToString();
+
+        public override string ToString()
+        {
+            return ptr == IntPtr.Zero ? string.Empty : godot_icall_StringName_operator_String(GetPtr(this));
+        }
+
+        public bool IsEmpty()
+        {
+            return ptr == IntPtr.Zero || godot_icall_StringName_is_empty(GetPtr(this));
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern IntPtr godot_icall_StringName_Ctor(string path);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void godot_icall_StringName_Dtor(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern string godot_icall_StringName_operator_String(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool godot_icall_StringName_is_empty(IntPtr ptr);
+    }
+}
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/GodotSharp.csproj b/modules/mono/glue/GodotSharp/GodotSharp/GodotSharp.csproj
index 5419cd06e6..799322c529 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/GodotSharp.csproj
+++ b/modules/mono/glue/GodotSharp/GodotSharp/GodotSharp.csproj
@@ -41,9 +41,11 @@
     <Compile Include="Core\Attributes\SignalAttribute.cs" />
     <Compile Include="Core\Attributes\ToolAttribute.cs" />
     <Compile Include="Core\Basis.cs" />
+    <Compile Include="Core\Callable.cs" />
     <Compile Include="Core\Color.cs" />
     <Compile Include="Core\Colors.cs" />
     <Compile Include="Core\DebuggingUtils.cs" />
+    <Compile Include="Core\DelegateUtils.cs" />
     <Compile Include="Core\Dictionary.cs" />
     <Compile Include="Core\Dispatcher.cs" />
     <Compile Include="Core\DynamicObject.cs" />
@@ -66,8 +68,10 @@
     <Compile Include="Core\Quat.cs" />
     <Compile Include="Core\Rect2.cs" />
     <Compile Include="Core\RID.cs" />
+    <Compile Include="Core\SignalInfo.cs" />
     <Compile Include="Core\SignalAwaiter.cs" />
     <Compile Include="Core\StringExtensions.cs" />
+    <Compile Include="Core\StringName.cs" />
     <Compile Include="Core\Transform.cs" />
     <Compile Include="Core\Transform2D.cs" />
     <Compile Include="Core\Vector2.cs" />
diff --git a/modules/mono/glue/base_object_glue.cpp b/modules/mono/glue/base_object_glue.cpp
index 8c77220b85..f7a2e7f1e7 100644
--- a/modules/mono/glue/base_object_glue.cpp
+++ b/modules/mono/glue/base_object_glue.cpp
@@ -126,18 +126,25 @@ void godot_icall_Reference_Disposed(MonoObject *p_obj, Object *p_ptr, MonoBoolea
 	}
 }
 
-MethodBind *godot_icall_Object_ClassDB_get_method(MonoString *p_type, MonoString *p_method) {
-	StringName type(GDMonoMarshal::mono_string_to_godot(p_type));
+void godot_icall_Object_ConnectEventSignals(Object *p_ptr) {
+	CSharpInstance *csharp_instance = CAST_CSHARP_INSTANCE(p_ptr->get_script_instance());
+	if (csharp_instance) {
+		csharp_instance->connect_event_signals();
+	}
+}
+
+MethodBind *godot_icall_Object_ClassDB_get_method(StringName *p_type, MonoString *p_method) {
+	StringName type = p_type ? *p_type : StringName();
 	StringName method(GDMonoMarshal::mono_string_to_godot(p_method));
 	return ClassDB::get_method(type, method);
 }
 
-MonoObject *godot_icall_Object_weakref(Object *p_obj) {
-	if (!p_obj)
+MonoObject *godot_icall_Object_weakref(Object *p_ptr) {
+	if (!p_ptr)
 		return NULL;
 
 	Ref<WeakRef> wref;
-	Reference *ref = Object::cast_to<Reference>(p_obj);
+	Reference *ref = Object::cast_to<Reference>(p_ptr);
 
 	if (ref) {
 		REF r = ref;
@@ -148,15 +155,15 @@ MonoObject *godot_icall_Object_weakref(Object *p_obj) {
 		wref->set_ref(r);
 	} else {
 		wref.instance();
-		wref->set_obj(p_obj);
+		wref->set_obj(p_ptr);
 	}
 
 	return GDMonoUtils::unmanaged_get_managed(wref.ptr());
 }
 
-Error godot_icall_SignalAwaiter_connect(Object *p_source, MonoString *p_signal, Object *p_target, MonoObject *p_awaiter) {
-	String signal = GDMonoMarshal::mono_string_to_godot(p_signal);
-	return SignalAwaiterUtils::connect_signal_awaiter(p_source, signal, p_target, p_awaiter);
+Error godot_icall_SignalAwaiter_connect(Object *p_source, StringName *p_signal, Object *p_target, MonoObject *p_awaiter) {
+	StringName signal = p_signal ? *p_signal : StringName();
+	return gd_mono_connect_signal_awaiter(p_source, signal, p_target, p_awaiter);
 }
 
 MonoArray *godot_icall_DynamicGodotObject_SetMemberList(Object *p_ptr) {
@@ -225,8 +232,8 @@ MonoString *godot_icall_Object_ToString(Object *p_ptr) {
 	// Cannot happen in C#; would get an ObjectDisposedException instead.
 	CRASH_COND(p_ptr == NULL);
 #endif
-
-	String result = p_ptr->to_string();
+	// Can't call 'Object::to_string()' here, as that can end up calling 'ToString' again resulting in an endless circular loop.
+	String result = "[" + p_ptr->get_class() + ":" + itos(p_ptr->get_instance_id()) + "]";
 	return GDMonoMarshal::mono_string_from_godot(result);
 }
 
diff --git a/modules/mono/glue/base_object_glue.h b/modules/mono/glue/base_object_glue.h
index 22532dcff9..67769f3061 100644
--- a/modules/mono/glue/base_object_glue.h
+++ b/modules/mono/glue/base_object_glue.h
@@ -44,11 +44,13 @@ void godot_icall_Object_Disposed(MonoObject *p_obj, Object *p_ptr);
 
 void godot_icall_Reference_Disposed(MonoObject *p_obj, Object *p_ptr, MonoBoolean p_is_finalizer);
 
-MethodBind *godot_icall_Object_ClassDB_get_method(MonoString *p_type, MonoString *p_method);
+void godot_icall_Object_ConnectEventSignals(Object *p_ptr);
 
-MonoObject *godot_icall_Object_weakref(Object *p_obj);
+MethodBind *godot_icall_Object_ClassDB_get_method(StringName *p_type, MonoString *p_method);
 
-Error godot_icall_SignalAwaiter_connect(Object *p_source, MonoString *p_signal, Object *p_target, MonoObject *p_awaiter);
+MonoObject *godot_icall_Object_weakref(Object *p_ptr);
+
+Error godot_icall_SignalAwaiter_connect(Object *p_source, StringName *p_signal, Object *p_target, MonoObject *p_awaiter);
 
 // DynamicGodotObject
 
diff --git a/modules/mono/glue/gd_glue.cpp b/modules/mono/glue/gd_glue.cpp
index cdacd90538..1576d31a3b 100644
--- a/modules/mono/glue/gd_glue.cpp
+++ b/modules/mono/glue/gd_glue.cpp
@@ -241,8 +241,9 @@ MonoObject *godot_icall_GD_str2var(MonoString *p_str) {
 	return GDMonoMarshal::variant_to_mono_object(ret);
 }
 
-MonoBoolean godot_icall_GD_type_exists(MonoString *p_type) {
-	return ClassDB::class_exists(GDMonoMarshal::mono_string_to_godot(p_type));
+MonoBoolean godot_icall_GD_type_exists(StringName *p_type) {
+	StringName type = p_type ? *p_type : StringName();
+	return ClassDB::class_exists(type);
 }
 
 void godot_icall_GD_pusherror(MonoString *p_str) {
@@ -273,6 +274,10 @@ MonoString *godot_icall_GD_var2str(MonoObject *p_var) {
 	return GDMonoMarshal::mono_string_from_godot(vars);
 }
 
+uint32_t godot_icall_TypeToVariantType(MonoReflectionType *p_refl_type) {
+	return (uint32_t)GDMonoMarshal::managed_to_variant_type(ManagedType::from_reftype(p_refl_type));
+}
+
 MonoObject *godot_icall_DefaultGodotTaskScheduler() {
 	return GDMonoCache::cached_data.task_scheduler_handle->get_target();
 }
@@ -300,6 +305,7 @@ void godot_register_gd_icalls() {
 	mono_add_internal_call("Godot.GD::godot_icall_GD_type_exists", (void *)godot_icall_GD_type_exists);
 	mono_add_internal_call("Godot.GD::godot_icall_GD_var2bytes", (void *)godot_icall_GD_var2bytes);
 	mono_add_internal_call("Godot.GD::godot_icall_GD_var2str", (void *)godot_icall_GD_var2str);
+	mono_add_internal_call("Godot.GD::godot_icall_TypeToVariantType", (void *)godot_icall_TypeToVariantType);
 
 	// Dispatcher
 	mono_add_internal_call("Godot.Dispatcher::godot_icall_DefaultGodotTaskScheduler", (void *)godot_icall_DefaultGodotTaskScheduler);
diff --git a/modules/mono/glue/gd_glue.h b/modules/mono/glue/gd_glue.h
index f00e2efc5d..3ad6058205 100644
--- a/modules/mono/glue/gd_glue.h
+++ b/modules/mono/glue/gd_glue.h
@@ -69,7 +69,7 @@ MonoString *godot_icall_GD_str(MonoArray *p_what);
 
 MonoObject *godot_icall_GD_str2var(MonoString *p_str);
 
-MonoBoolean godot_icall_GD_type_exists(MonoString *p_type);
+MonoBoolean godot_icall_GD_type_exists(StringName *p_type);
 
 MonoArray *godot_icall_GD_var2bytes(MonoObject *p_var, MonoBoolean p_full_objects);
 
diff --git a/modules/mono/glue/glue_header.h b/modules/mono/glue/glue_header.h
index 758b71f719..8130b0cc39 100644
--- a/modules/mono/glue/glue_header.h
+++ b/modules/mono/glue/glue_header.h
@@ -36,6 +36,7 @@
 #include "nodepath_glue.h"
 #include "rid_glue.h"
 #include "string_glue.h"
+#include "string_name_glue.h"
 
 /**
  * Registers internal calls that were not generated. This function is called
@@ -44,6 +45,7 @@
 void godot_register_glue_header_icalls() {
 	godot_register_collections_icalls();
 	godot_register_gd_icalls();
+	godot_register_string_name_icalls();
 	godot_register_nodepath_icalls();
 	godot_register_object_icalls();
 	godot_register_rid_icalls();
diff --git a/modules/mono/glue/string_name_glue.cpp b/modules/mono/glue/string_name_glue.cpp
new file mode 100644
index 0000000000..81006e5849
--- /dev/null
+++ b/modules/mono/glue/string_name_glue.cpp
@@ -0,0 +1,61 @@
+/*************************************************************************/
+/*  string_name_glue.cpp                                                 */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "string_name_glue.h"
+
+#ifdef MONO_GLUE_ENABLED
+
+#include "core/ustring.h"
+
+StringName *godot_icall_StringName_Ctor(MonoString *p_path) {
+	return memnew(StringName(GDMonoMarshal::mono_string_to_godot(p_path)));
+}
+
+void godot_icall_StringName_Dtor(StringName *p_ptr) {
+	ERR_FAIL_NULL(p_ptr);
+	memdelete(p_ptr);
+}
+
+MonoString *godot_icall_StringName_operator_String(StringName *p_np) {
+	return GDMonoMarshal::mono_string_from_godot(p_np->operator String());
+}
+
+MonoBoolean godot_icall_StringName_is_empty(StringName *p_ptr) {
+	return (MonoBoolean)(p_ptr == StringName());
+}
+
+void godot_register_string_name_icalls() {
+	mono_add_internal_call("Godot.StringName::godot_icall_StringName_Ctor", (void *)godot_icall_StringName_Ctor);
+	mono_add_internal_call("Godot.StringName::godot_icall_StringName_Dtor", (void *)godot_icall_StringName_Dtor);
+	mono_add_internal_call("Godot.StringName::godot_icall_StringName_operator_String", (void *)godot_icall_StringName_operator_String);
+	mono_add_internal_call("Godot.StringName::godot_icall_StringName_is_empty", (void *)godot_icall_StringName_is_empty);
+}
+
+#endif // MONO_GLUE_ENABLED
diff --git a/modules/mono/glue/string_name_glue.h b/modules/mono/glue/string_name_glue.h
new file mode 100644
index 0000000000..88354ddd84
--- /dev/null
+++ b/modules/mono/glue/string_name_glue.h
@@ -0,0 +1,54 @@
+/*************************************************************************/
+/*  string_name_glue.h                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef STRING_NAME_GLUE_H
+#define STRING_NAME_GLUE_H
+
+#ifdef MONO_GLUE_ENABLED
+
+#include "core/string_name.h"
+
+#include "../mono_gd/gd_mono_marshal.h"
+
+StringName *godot_icall_StringName_Ctor(MonoString *p_path);
+
+void godot_icall_StringName_Dtor(StringName *p_ptr);
+
+MonoString *godot_icall_StringName_operator_String(StringName *p_np);
+
+MonoBoolean godot_icall_StringName_is_empty(StringName *p_ptr);
+
+// Register internal calls
+
+void godot_register_string_name_icalls();
+
+#endif // MONO_GLUE_ENABLED
+
+#endif // STRING_NAME_GLUE_H