Merge pull request #21990 from neikeq/howwouldyounamethisbranch

C#/Mono fixes and enhancements

9 files changed, 489 insertions, 119 deletions

diff --git a/modules/mono/glue/cs_files/Array.cs b/modules/mono/glue/cs_files/Array.cs
index 2f0185b1e3..c80cb7cc83 100644
--- a/modules/mono/glue/cs_files/Array.cs
+++ b/modules/mono/glue/cs_files/Array.cs
@@ -30,45 +30,6 @@ namespace Godot.Collections
 
     public class Array : IList<object>, ICollection<object>, IEnumerable<object>, IDisposable
     {
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static IntPtr godot_icall_Array_Ctor();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_Array_Dtor(IntPtr ptr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static object godot_icall_Array_At(IntPtr ptr, int index);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_Array_SetAt(IntPtr ptr, int index, object value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static int godot_icall_Array_Count(IntPtr ptr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_Array_Add(IntPtr ptr, object item);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_Array_Clear(IntPtr ptr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static bool godot_icall_Array_Contains(IntPtr ptr, object item);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_Array_CopyTo(IntPtr ptr, object[] array, int arrayIndex);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static int godot_icall_Array_IndexOf(IntPtr ptr, object item);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_Array_Insert(IntPtr ptr, int index, object item);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static bool godot_icall_Array_Remove(IntPtr ptr, object item);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_Array_RemoveAt(IntPtr ptr, int index);
-
         ArraySafeHandle safeHandle;
         bool disposed = false;
 
@@ -94,11 +55,6 @@ namespace Godot.Collections
 
         public void Dispose()
         {
-            Dispose(true);
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
             if (disposed)
                 return;
 
@@ -200,6 +156,45 @@ namespace Godot.Collections
         {
             return GetEnumerator();
         }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static IntPtr godot_icall_Array_Ctor();
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_Array_Dtor(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static object godot_icall_Array_At(IntPtr ptr, int index);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_Array_SetAt(IntPtr ptr, int index, object value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static int godot_icall_Array_Count(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_Array_Add(IntPtr ptr, object item);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_Array_Clear(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static bool godot_icall_Array_Contains(IntPtr ptr, object item);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_Array_CopyTo(IntPtr ptr, object[] array, int arrayIndex);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static int godot_icall_Array_IndexOf(IntPtr ptr, object item);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_Array_Insert(IntPtr ptr, int index, object item);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static bool godot_icall_Array_Remove(IntPtr ptr, object item);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_Array_RemoveAt(IntPtr ptr, int index);
     }
 
     public class Array<T> : IList<T>, ICollection<T>, IEnumerable<T>
diff --git a/modules/mono/glue/cs_files/Dictionary.cs b/modules/mono/glue/cs_files/Dictionary.cs
index 64cb9f935d..523e48c31a 100644
--- a/modules/mono/glue/cs_files/Dictionary.cs
+++ b/modules/mono/glue/cs_files/Dictionary.cs
@@ -34,48 +34,6 @@ namespace Godot.Collections
         IEnumerable<KeyValuePair<object, object>>,
         IDisposable
     {
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static IntPtr godot_icall_Dictionary_Ctor();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_Dictionary_Dtor(IntPtr ptr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static object godot_icall_Dictionary_GetValue(IntPtr ptr, object key);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_Dictionary_SetValue(IntPtr ptr, object key, object value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static IntPtr godot_icall_Dictionary_Keys(IntPtr ptr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static IntPtr godot_icall_Dictionary_Values(IntPtr ptr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static int godot_icall_Dictionary_Count(IntPtr ptr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_Dictionary_Add(IntPtr ptr, object key, object value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static void godot_icall_Dictionary_Clear(IntPtr ptr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static bool godot_icall_Dictionary_Contains(IntPtr ptr, object key, object value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static bool godot_icall_Dictionary_ContainsKey(IntPtr ptr, object key);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static bool godot_icall_Dictionary_RemoveKey(IntPtr ptr, object key);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static bool godot_icall_Dictionary_Remove(IntPtr ptr, object key, object value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static bool godot_icall_Dictionary_TryGetValue(IntPtr ptr, object key, out object value);
-
         DictionarySafeHandle safeHandle;
         bool disposed = false;
 
@@ -101,11 +59,6 @@ namespace Godot.Collections
 
         public void Dispose()
         {
-            Dispose(true);
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
             if (disposed)
                 return;
 
@@ -240,8 +193,49 @@ namespace Godot.Collections
         {
             return GetEnumerator();
         }
-    }
 
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static IntPtr godot_icall_Dictionary_Ctor();
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_Dictionary_Dtor(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static object godot_icall_Dictionary_GetValue(IntPtr ptr, object key);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_Dictionary_SetValue(IntPtr ptr, object key, object value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static IntPtr godot_icall_Dictionary_Keys(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static IntPtr godot_icall_Dictionary_Values(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static int godot_icall_Dictionary_Count(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_Dictionary_Add(IntPtr ptr, object key, object value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_Dictionary_Clear(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static bool godot_icall_Dictionary_Contains(IntPtr ptr, object key, object value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static bool godot_icall_Dictionary_ContainsKey(IntPtr ptr, object key);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static bool godot_icall_Dictionary_RemoveKey(IntPtr ptr, object key);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static bool godot_icall_Dictionary_Remove(IntPtr ptr, object key, object value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static bool godot_icall_Dictionary_TryGetValue(IntPtr ptr, object key, out object value);
+    }
 
     public class Dictionary<TKey, TValue> :
         IDictionary<TKey, TValue>,
diff --git a/modules/mono/glue/cs_files/Extensions/ObjectExtensions.cs b/modules/mono/glue/cs_files/Extensions/ObjectExtensions.cs
index 5c9e6609f4..9ef0959750 100644
--- a/modules/mono/glue/cs_files/Extensions/ObjectExtensions.cs
+++ b/modules/mono/glue/cs_files/Extensions/ObjectExtensions.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.CompilerServices;
 
 namespace Godot
 {
@@ -11,7 +12,10 @@ namespace Godot
 
         public static WeakRef WeakRef(Object obj)
         {
-            return NativeCalls.godot_icall_Godot_weakref(Object.GetPtr(obj));
+            return godot_icall_Object_weakref(Object.GetPtr(obj));
         }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static WeakRef godot_icall_Object_weakref(IntPtr obj);
     }
 }
diff --git a/modules/mono/glue/cs_files/GD.cs b/modules/mono/glue/cs_files/GD.cs
index 0a5d703f27..264be23588 100644
--- a/modules/mono/glue/cs_files/GD.cs
+++ b/modules/mono/glue/cs_files/GD.cs
@@ -1,11 +1,12 @@
 using System;
+using System.Runtime.CompilerServices;
 #if REAL_T_IS_DOUBLE
 using real_t = System.Double;
 #else
 using real_t = System.Single;
 #endif
 
-// TODO: Add comments describing what this class does. It is not obvious. 
+// TODO: Add comments describing what this class does. It is not obvious.
 
 namespace Godot
 {
@@ -13,12 +14,12 @@ namespace Godot
     {
         public static object Bytes2Var(byte[] bytes)
         {
-            return NativeCalls.godot_icall_Godot_bytes2var(bytes);
+            return godot_icall_GD_bytes2var(bytes);
         }
 
         public static object Convert(object what, int type)
         {
-            return NativeCalls.godot_icall_Godot_convert(what, type);
+            return godot_icall_GD_convert(what, type);
         }
 
         public static real_t Db2Linear(real_t db)
@@ -46,12 +47,12 @@ namespace Godot
 
         public static int Hash(object var)
         {
-            return NativeCalls.godot_icall_Godot_hash(var);
+            return godot_icall_GD_hash(var);
         }
 
         public static Object InstanceFromId(int instanceId)
         {
-            return NativeCalls.godot_icall_Godot_instance_from_id(instanceId);
+            return godot_icall_GD_instance_from_id(instanceId);
         }
 
         public static real_t Linear2Db(real_t linear)
@@ -71,7 +72,7 @@ namespace Godot
 
         public static void Print(params object[] what)
         {
-            NativeCalls.godot_icall_Godot_print(what);
+            godot_icall_GD_print(what);
         }
 
         public static void PrintStack()
@@ -81,22 +82,22 @@ namespace Godot
 
         public static void PrintErr(params object[] what)
         {
-            NativeCalls.godot_icall_Godot_printerr(what);
+            godot_icall_GD_printerr(what);
         }
 
         public static void PrintRaw(params object[] what)
         {
-            NativeCalls.godot_icall_Godot_printraw(what);
+            godot_icall_GD_printraw(what);
         }
 
         public static void PrintS(params object[] what)
         {
-            NativeCalls.godot_icall_Godot_prints(what);
+            godot_icall_GD_prints(what);
         }
 
         public static void PrintT(params object[] what)
         {
-            NativeCalls.godot_icall_Godot_printt(what);
+            godot_icall_GD_printt(what);
         }
 
         public static int[] Range(int length)
@@ -165,32 +166,77 @@ namespace Godot
 
         public static void Seed(int seed)
         {
-            NativeCalls.godot_icall_Godot_seed(seed);
+            godot_icall_GD_seed(seed);
         }
 
         public static string Str(params object[] what)
         {
-            return NativeCalls.godot_icall_Godot_str(what);
+            return godot_icall_GD_str(what);
         }
 
         public static object Str2Var(string str)
         {
-            return NativeCalls.godot_icall_Godot_str2var(str);
+            return godot_icall_GD_str2var(str);
         }
 
         public static bool TypeExists(string type)
         {
-            return NativeCalls.godot_icall_Godot_type_exists(type);
+            return godot_icall_GD_type_exists(type);
         }
 
         public static byte[] Var2Bytes(object var)
         {
-            return NativeCalls.godot_icall_Godot_var2bytes(var);
+            return godot_icall_GD_var2bytes(var);
         }
 
         public static string Var2Str(object var)
         {
-            return NativeCalls.godot_icall_Godot_var2str(var);
+            return godot_icall_GD_var2str(var);
         }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static object godot_icall_GD_bytes2var(byte[] bytes);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static object godot_icall_GD_convert(object what, int type);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static int godot_icall_GD_hash(object var);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static Object godot_icall_GD_instance_from_id(int instance_id);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_GD_print(object[] what);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_GD_printerr(object[] what);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_GD_printraw(object[] what);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_GD_prints(object[] what);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_GD_printt(object[] what);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_GD_seed(int seed);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static string godot_icall_GD_str(object[] what);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static object godot_icall_GD_str2var(string str);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static bool godot_icall_GD_type_exists(string type);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static byte[] godot_icall_GD_var2bytes(object what);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static string godot_icall_GD_var2str(object var);
     }
 }
diff --git a/modules/mono/glue/cs_files/NodePath.cs b/modules/mono/glue/cs_files/NodePath.cs
new file mode 100644
index 0000000000..2c89bec87f
--- /dev/null
+++ b/modules/mono/glue/cs_files/NodePath.cs
@@ -0,0 +1,147 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Godot
+{
+    public partial class NodePath : IDisposable
+    {
+        private bool disposed = false;
+
+        internal IntPtr ptr;
+
+        internal static IntPtr GetPtr(NodePath instance)
+        {
+            return instance == null ? IntPtr.Zero : instance.ptr;
+        }
+
+        ~NodePath()
+        {
+            Dispose(false);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposed)
+                return;
+
+            if (ptr != IntPtr.Zero)
+            {
+                godot_icall_NodePath_Dtor(ptr);
+                ptr = IntPtr.Zero;
+            }
+
+            disposed = true;
+        }
+
+        internal NodePath(IntPtr ptr)
+        {
+            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);
+        }
+
+        public static implicit operator NodePath(string from)
+        {
+            return new NodePath(from);
+        }
+
+        public static implicit operator string(NodePath from)
+        {
+            return godot_icall_NodePath_operator_String(NodePath.GetPtr(from));
+        }
+
+        public override string ToString()
+        {
+            return (string)this;
+        }
+
+        public NodePath GetAsPropertyPath()
+        {
+            return new NodePath(godot_icall_NodePath_get_as_property_path(NodePath.GetPtr(this)));
+        }
+
+        public string GetConcatenatedSubnames()
+        {
+            return godot_icall_NodePath_get_concatenated_subnames(NodePath.GetPtr(this));
+        }
+
+        public string GetName(int idx)
+        {
+            return godot_icall_NodePath_get_name(NodePath.GetPtr(this), idx);
+        }
+
+        public int GetNameCount()
+        {
+            return godot_icall_NodePath_get_name_count(NodePath.GetPtr(this));
+        }
+
+        public string GetSubname(int idx)
+        {
+            return godot_icall_NodePath_get_subname(NodePath.GetPtr(this), idx);
+        }
+
+        public int GetSubnameCount()
+        {
+            return godot_icall_NodePath_get_subname_count(NodePath.GetPtr(this));
+        }
+
+        public bool IsAbsolute()
+        {
+            return godot_icall_NodePath_is_absolute(NodePath.GetPtr(this));
+        }
+
+        public bool IsEmpty()
+        {
+            return godot_icall_NodePath_is_empty(NodePath.GetPtr(this));
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static IntPtr godot_icall_NodePath_Ctor(string path);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_NodePath_Dtor(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static string godot_icall_NodePath_operator_String(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static 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);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static 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);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static 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);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static bool godot_icall_NodePath_is_absolute(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static bool godot_icall_NodePath_is_empty(IntPtr ptr);
+    }
+}
diff --git a/modules/mono/glue/cs_files/Object.base.cs b/modules/mono/glue/cs_files/Object.base.cs
new file mode 100644
index 0000000000..30490a715f
--- /dev/null
+++ b/modules/mono/glue/cs_files/Object.base.cs
@@ -0,0 +1,88 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Godot
+{
+    public partial class Object : IDisposable
+    {
+        private bool disposed = false;
+
+        private const string nativeName = "Object";
+
+        internal IntPtr ptr;
+        internal bool memoryOwn;
+
+        public Object() : this(false)
+        {
+            if (ptr == IntPtr.Zero)
+                ptr = godot_icall_Object_Ctor(this);
+        }
+
+        internal Object(bool memoryOwn)
+        {
+            this.memoryOwn = memoryOwn;
+        }
+
+        public IntPtr NativeInstance
+        {
+            get { return ptr; }
+        }
+
+        internal static IntPtr GetPtr(Object instance)
+        {
+            return instance == null ? IntPtr.Zero : instance.ptr;
+        }
+
+        ~Object()
+        {
+            Dispose(false);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposed)
+                return;
+
+            if (ptr != IntPtr.Zero)
+            {
+                if (memoryOwn)
+                {
+                    memoryOwn = false;
+                    godot_icall_Reference_Disposed(this, ptr, !disposing);
+                }
+                else
+                {
+                    godot_icall_Object_Disposed(this, ptr);
+                }
+
+                this.ptr = IntPtr.Zero;
+            }
+
+            disposed = true;
+        }
+
+        public SignalAwaiter ToSignal(Object source, string signal)
+        {
+            return new SignalAwaiter(source, signal, this);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static IntPtr godot_icall_Object_Ctor(Object obj);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_Object_Disposed(Object obj, IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_Reference_Disposed(Object obj, IntPtr ptr, bool isFinalizer);
+
+        // Used by the generated API
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static IntPtr godot_icall_Object_ClassDB_get_method(string type, string method);
+    }
+}
diff --git a/modules/mono/glue/cs_files/RID.cs b/modules/mono/glue/cs_files/RID.cs
new file mode 100644
index 0000000000..b862b8cac0
--- /dev/null
+++ b/modules/mono/glue/cs_files/RID.cs
@@ -0,0 +1,76 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Godot
+{
+    public partial class RID : IDisposable
+    {
+        private bool disposed = false;
+
+        internal IntPtr ptr;
+
+        internal static IntPtr GetPtr(RID instance)
+        {
+            return instance == null ? IntPtr.Zero : instance.ptr;
+        }
+
+        ~RID()
+        {
+            Dispose(false);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposed)
+                return;
+
+            if (ptr != IntPtr.Zero)
+            {
+                godot_icall_RID_Dtor(ptr);
+                ptr = IntPtr.Zero;
+            }
+
+            disposed = true;
+        }
+
+        internal RID(IntPtr ptr)
+        {
+            this.ptr = ptr;
+        }
+
+        public IntPtr NativeInstance
+        {
+            get { return ptr; }
+        }
+
+        internal RID()
+        {
+            this.ptr = IntPtr.Zero;
+        }
+
+        public RID(Object from)
+        {
+            this.ptr = godot_icall_RID_Ctor(Object.GetPtr(from));
+        }
+
+        public int GetId()
+        {
+            return godot_icall_RID_get_id(RID.GetPtr(this));
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static IntPtr godot_icall_RID_Ctor(IntPtr from);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static void godot_icall_RID_Dtor(IntPtr ptr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static int godot_icall_RID_get_id(IntPtr ptr);
+    }
+}
diff --git a/modules/mono/glue/cs_files/SignalAwaiter.cs b/modules/mono/glue/cs_files/SignalAwaiter.cs
index c06f6b05c9..9483b6ffb4 100644
--- a/modules/mono/glue/cs_files/SignalAwaiter.cs
+++ b/modules/mono/glue/cs_files/SignalAwaiter.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.CompilerServices;
 
 namespace Godot
 {
@@ -10,12 +11,12 @@ namespace Godot
 
         public SignalAwaiter(Object source, string signal, Object target)
         {
-            NativeCalls.godot_icall_Object_connect_signal_awaiter(
-                Object.GetPtr(source),
-                signal, Object.GetPtr(target), this
-                );
+            godot_icall_SignalAwaiter_connect(Object.GetPtr(source), signal, Object.GetPtr(target), this);
         }
 
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static Error godot_icall_SignalAwaiter_connect(IntPtr source, string signal, IntPtr target, SignalAwaiter awaiter);
+
         public bool IsCompleted
         {
             get
diff --git a/modules/mono/glue/cs_files/StringExtensions.cs b/modules/mono/glue/cs_files/StringExtensions.cs
index cda573f6c5..21c9be98c1 100644
--- a/modules/mono/glue/cs_files/StringExtensions.cs
+++ b/modules/mono/glue/cs_files/StringExtensions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.Runtime.CompilerServices;
 using System.Security;
 using System.Text;
 using System.Text.RegularExpressions;
@@ -609,17 +610,23 @@ namespace Godot
         // </summary>
         public static byte[] MD5Buffer(this string instance)
         {
-            return NativeCalls.godot_icall_String_md5_buffer(instance);
+            return godot_icall_String_md5_buffer(instance);
         }
 
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static byte[] godot_icall_String_md5_buffer(string str);
+
         // <summary>
         // Return the MD5 hash of the string as a string.
         // </summary>
         public static string MD5Text(this string instance)
         {
-            return NativeCalls.godot_icall_String_md5_text(instance);
+            return godot_icall_String_md5_text(instance);
         }
 
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static string godot_icall_String_md5_text(string str);
+
         // <summary>
         // Perform a case-insensitive comparison to another string, return -1 if less, 0 if equal and +1 if greater.
         // </summary>
@@ -752,17 +759,23 @@ namespace Godot
         // </summary>
         public static int RFind(this string instance, string what, int from = -1)
         {
-            return NativeCalls.godot_icall_String_rfind(instance, what, from);
+            return godot_icall_String_rfind(instance, what, from);
         }
 
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static int godot_icall_String_rfind(string str, string what, int from);
+
         // <summary>
         // Perform a search for a substring, but start from the end of the string instead of the beginning. Also search case-insensitive.
         // </summary>
         public static int RFindN(this string instance, string what, int from = -1)
         {
-            return NativeCalls.godot_icall_String_rfindn(instance, what, from);
+            return godot_icall_String_rfindn(instance, what, from);
         }
 
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static int godot_icall_String_rfindn(string str, string what, int from);
+
         // <summary>
         // Return the right side of the string from a given position.
         // </summary>
@@ -779,17 +792,23 @@ namespace Godot
 
         public static byte[] SHA256Buffer(this string instance)
         {
-            return NativeCalls.godot_icall_String_sha256_buffer(instance);
+            return godot_icall_String_sha256_buffer(instance);
         }
 
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static byte[] godot_icall_String_sha256_buffer(string str);
+
         // <summary>
         // Return the SHA-256 hash of the string as a string.
         // </summary>
         public static string SHA256Text(this string instance)
         {
-            return NativeCalls.godot_icall_String_sha256_text(instance);
+            return godot_icall_String_sha256_text(instance);
         }
 
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal extern static string godot_icall_String_sha256_text(string str);
+
         // <summary>
         // Return the similarity index of the text compared to this string. 1 means totally similar and 0 means totally dissimilar.
         // </summary>