C#: Restructure code prior move to .NET Core

The main focus here was to remove the majority of code that relied on
Mono's embedding APIs, specially the reflection APIs. The embedding
APIs we still use are the bare minimum we need for things to work.
A lot of code was moved to C#. We no longer deal with any managed
objects (`MonoObject*`, and such) in native code, and all marshaling
is done in C#.

The reason for restructuring the code and move away from embedding APIs
is that once we move to .NET Core, we will be limited by the much more
minimal .NET hosting.

PERFORMANCE REGRESSIONS
-----------------------

Some parts of the code were written with little to no concern about
performance. This includes code that calls into script methods and
accesses script fields, properties and events.
The reason for this is that all of that will be moved to source
generators, so any work prior to that would be a waste of time.

DISABLED FEATURES
-----------------

Some code was removed as it no longer makes sense (or won't make sense
in the future).
Other parts were commented out with `#if 0`s and TODO warnings because
it doesn't make much sense to work on them yet as those parts will
change heavily when we switch to .NET Core but also when we start
introducing source generators.
As such, the following features were disabled temporarily:
- Assembly-reloading (will be done with ALCs in .NET Core).
- Properties/fields exports and script method listing (will be
  handled by source generators in the future).
- Exception logging in the editor and stack info for errors.
- Exporting games.
- Building of C# projects. We no longer copy the Godot API assemblies
  to the project directory, so MSBuild won't be able to find them. The
  idea is to turn them into NuGet packages in the future, which could
  also be obtained from local NuGet sources during development.

9 files changed, 248 insertions, 189 deletions

diff --git a/modules/mono/editor/GodotTools/GodotTools/Build/BuildManager.cs b/modules/mono/editor/GodotTools/GodotTools/Build/BuildManager.cs
index 21bff70b15..33967ffa71 100644
--- a/modules/mono/editor/GodotTools/GodotTools/Build/BuildManager.cs
+++ b/modules/mono/editor/GodotTools/GodotTools/Build/BuildManager.cs
@@ -178,17 +178,6 @@ namespace GodotTools.Build
             if (!File.Exists(buildInfo.Solution))
                 return true; // No solution to build
 
-            // Make sure the API assemblies are up to date before building the project.
-            // We may not have had the chance to update the release API assemblies, and the debug ones
-            // may have been deleted by the user at some point after they were loaded by the Godot editor.
-            string apiAssembliesUpdateError = Internal.UpdateApiAssembliesFromPrebuilt(buildInfo.Configuration == "ExportRelease" ? "Release" : "Debug");
-
-            if (!string.IsNullOrEmpty(apiAssembliesUpdateError))
-            {
-                ShowBuildErrorDialog("Failed to update the Godot API assemblies");
-                return false;
-            }
-
             using (var pr = new EditorProgress("mono_project_debug_build", "Building project solution...", 1))
             {
                 pr.Step("Building project solution", 0);
diff --git a/modules/mono/editor/GodotTools/GodotTools/Export/ExportPlugin.cs b/modules/mono/editor/GodotTools/GodotTools/Export/ExportPlugin.cs
index cca18a2a1f..ee3f5999cd 100644
--- a/modules/mono/editor/GodotTools/GodotTools/Export/ExportPlugin.cs
+++ b/modules/mono/editor/GodotTools/GodotTools/Export/ExportPlugin.cs
@@ -1,4 +1,5 @@
 using Godot;
+using Godot.NativeInterop;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -100,7 +101,9 @@ namespace GodotTools.Export
                 return;
 
             if (Path.GetExtension(path) != Internal.CSharpLanguageExtension)
-                throw new ArgumentException($"Resource of type {Internal.CSharpLanguageType} has an invalid file extension: {path}", nameof(path));
+                throw new ArgumentException(
+                    $"Resource of type {Internal.CSharpLanguageType} has an invalid file extension: {path}",
+                    nameof(path));
 
             // TODO What if the source file is not part of the game's C# project
 
@@ -194,7 +197,8 @@ namespace GodotTools.Export
                 {
                     string thisWasmFrameworkAssemblyPath = Path.Combine(bclDir, thisWasmFrameworkAssemblyName + ".dll");
                     if (!File.Exists(thisWasmFrameworkAssemblyPath))
-                        throw new FileNotFoundException($"Assembly not found: '{thisWasmFrameworkAssemblyName}'", thisWasmFrameworkAssemblyPath);
+                        throw new FileNotFoundException($"Assembly not found: '{thisWasmFrameworkAssemblyName}'",
+                            thisWasmFrameworkAssemblyPath);
                     assemblies[thisWasmFrameworkAssemblyName] = thisWasmFrameworkAssemblyPath;
                 }
 
@@ -206,18 +210,21 @@ namespace GodotTools.Export
 
                 foreach (var thisWasmFrameworkAssemblyName in wasmFrameworkAssembliesOneOf)
                 {
-                    string thisWasmFrameworkAssemblyPath = Path.Combine(bclDir, thisWasmFrameworkAssemblyName.newName + ".dll");
+                    string thisWasmFrameworkAssemblyPath =
+                        Path.Combine(bclDir, thisWasmFrameworkAssemblyName.newName + ".dll");
                     if (File.Exists(thisWasmFrameworkAssemblyPath))
                     {
                         assemblies[thisWasmFrameworkAssemblyName.newName] = thisWasmFrameworkAssemblyPath;
                     }
                     else
                     {
-                        thisWasmFrameworkAssemblyPath = Path.Combine(bclDir, thisWasmFrameworkAssemblyName.oldName + ".dll");
+                        thisWasmFrameworkAssemblyPath =
+                            Path.Combine(bclDir, thisWasmFrameworkAssemblyName.oldName + ".dll");
                         if (!File.Exists(thisWasmFrameworkAssemblyPath))
                         {
-                            throw new FileNotFoundException("Expected one of the following assemblies but none were found: " +
-                                                            $"'{thisWasmFrameworkAssemblyName.newName}' / '{thisWasmFrameworkAssemblyName.oldName}'",
+                            throw new FileNotFoundException(
+                                "Expected one of the following assemblies but none were found: " +
+                                $"'{thisWasmFrameworkAssemblyName.newName}' / '{thisWasmFrameworkAssemblyName.oldName}'",
                                 thisWasmFrameworkAssemblyPath);
                         }
 
@@ -227,7 +234,12 @@ namespace GodotTools.Export
             }
 
             var initialAssemblies = assemblies.Duplicate();
-            internal_GetExportedAssemblyDependencies(initialAssemblies, buildConfig, bclDir, assemblies);
+            godot_dictionary initialAssembliesAux = ((Godot.Collections.Dictionary)initialAssemblies).NativeValue;
+            using godot_string buildConfigAux = Marshaling.mono_string_to_godot(buildConfig);
+            using godot_string bclDirAux = Marshaling.mono_string_to_godot(bclDir);
+            godot_dictionary assembliesAux = ((Godot.Collections.Dictionary)assemblies).NativeValue;
+            internal_GetExportedAssemblyDependencies(initialAssembliesAux, buildConfigAux, bclDirAux,
+                ref assembliesAux);
 
             AddI18NAssemblies(assemblies, bclDir);
 
@@ -237,9 +249,12 @@ namespace GodotTools.Export
                 outputDataDir = ExportDataDirectory(features, platform, isDebug, outputDir);
 
             string apiConfig = isDebug ? "Debug" : "Release";
-            string resAssembliesDir = Path.Combine(GodotSharpDirs.ResAssembliesBaseDir, apiConfig);
+            // TODO
+            throw new NotImplementedException();
+            string resAssembliesDir = null; // Path.Combine(GodotSharpDirs.ResAssembliesBaseDir, apiConfig);
 
-            bool assembliesInsidePck = (bool)ProjectSettings.GetSetting("mono/export/export_assemblies_inside_pck") || outputDataDir == null;
+            bool assembliesInsidePck = (bool)ProjectSettings.GetSetting("mono/export/export_assemblies_inside_pck") ||
+                                       outputDataDir == null;
 
             if (!assembliesInsidePck)
             {
@@ -277,7 +292,8 @@ namespace GodotTools.Export
             }
 
             // AOT compilation
-            bool aotEnabled = platform == OS.Platforms.iOS || (bool)ProjectSettings.GetSetting("mono/export/aot/enabled");
+            bool aotEnabled = platform == OS.Platforms.iOS ||
+                              (bool)ProjectSettings.GetSetting("mono/export/aot/enabled");
 
             if (aotEnabled)
             {
@@ -296,14 +312,19 @@ namespace GodotTools.Export
                     LLVMOnly = false,
                     LLVMPath = "",
                     LLVMOutputPath = "",
-                    FullAot = platform == OS.Platforms.iOS || (bool)(ProjectSettings.GetSetting("mono/export/aot/full_aot") ?? false),
+                    FullAot = platform == OS.Platforms.iOS ||
+                              (bool)(ProjectSettings.GetSetting("mono/export/aot/full_aot") ?? false),
                     UseInterpreter = (bool)ProjectSettings.GetSetting("mono/export/aot/use_interpreter"),
-                    ExtraAotOptions = (string[])ProjectSettings.GetSetting("mono/export/aot/extra_aot_options") ?? Array.Empty<string>(),
-                    ExtraOptimizerOptions = (string[])ProjectSettings.GetSetting("mono/export/aot/extra_optimizer_options") ?? Array.Empty<string>(),
+                    ExtraAotOptions = (string[])ProjectSettings.GetSetting("mono/export/aot/extra_aot_options") ??
+                                      Array.Empty<string>(),
+                    ExtraOptimizerOptions =
+                        (string[])ProjectSettings.GetSetting("mono/export/aot/extra_optimizer_options") ??
+                        Array.Empty<string>(),
                     ToolchainPath = aotToolchainPath
                 };
 
-                AotBuilder.CompileAssemblies(this, aotOpts, features, platform, isDebug, bclDir, outputDir, outputDataDir, assemblies);
+                AotBuilder.CompileAssemblies(this, aotOpts, features, platform, isDebug, bclDir, outputDir,
+                    outputDataDir, assemblies);
             }
         }
 
@@ -316,8 +337,10 @@ namespace GodotTools.Export
             if (Directory.Exists(aotTempDir))
                 Directory.Delete(aotTempDir, recursive: true);
 
-            // TODO: Just a workaround until the export plugins can be made to abort with errors
-            if (!string.IsNullOrEmpty(_maybeLastExportError)) // Check empty as well, because it's set to empty after hot-reloading
+            // TODO: The following is just a workaround until the export plugins can be made to abort with errors
+
+            // We check for empty as well, because it's set to empty after hot-reloading
+            if (!string.IsNullOrEmpty(_maybeLastExportError))
             {
                 string lastExportError = _maybeLastExportError;
                 _maybeLastExportError = null;
@@ -381,7 +404,8 @@ namespace GodotTools.Export
         private static bool PlatformHasTemplateDir(string platform)
         {
             // macOS export templates are contained in a zip, so we place our custom template inside it and let Godot do the rest.
-            return !new[] { OS.Platforms.MacOS, OS.Platforms.Android, OS.Platforms.iOS, OS.Platforms.HTML5 }.Contains(platform);
+            return !new[] { OS.Platforms.MacOS, OS.Platforms.Android, OS.Platforms.iOS, OS.Platforms.HTML5 }
+                .Contains(platform);
         }
 
         private static bool DeterminePlatformFromFeatures(IEnumerable<string> features, out string platform)
@@ -476,7 +500,8 @@ namespace GodotTools.Export
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void internal_GetExportedAssemblyDependencies(Godot.Collections.Dictionary<string, string> initialAssemblies,
-            string buildConfig, string customBclDir, Godot.Collections.Dictionary<string, string> dependencyAssemblies);
+        private static extern void internal_GetExportedAssemblyDependencies(
+            in godot_dictionary initialAssemblies, in godot_string buildConfig,
+            in godot_string customBclDir, ref godot_dictionary dependencyAssemblies);
     }
 }
diff --git a/modules/mono/editor/GodotTools/GodotTools/GodotSharpEditor.cs b/modules/mono/editor/GodotTools/GodotTools/GodotSharpEditor.cs
index b39c3d1c0d..5167333716 100644
--- a/modules/mono/editor/GodotTools/GodotTools/GodotSharpEditor.cs
+++ b/modules/mono/editor/GodotTools/GodotTools/GodotSharpEditor.cs
@@ -53,7 +53,7 @@ namespace GodotTools
 
         private bool CreateProjectSolution()
         {
-            using (var pr = new EditorProgress("create_csharp_solution", "Generating solution...".TTR(), 3))
+            using (var pr = new EditorProgress("create_csharp_solution", "Generating solution...".TTR(), 2))
             {
                 pr.Step("Generating C# project...".TTR());
 
@@ -90,24 +90,6 @@ namespace GodotTools
                         return false;
                     }
 
-                    pr.Step("Updating Godot API assemblies...".TTR());
-
-                    string debugApiAssembliesError = Internal.UpdateApiAssembliesFromPrebuilt("Debug");
-
-                    if (!string.IsNullOrEmpty(debugApiAssembliesError))
-                    {
-                        ShowErrorDialog("Failed to update the Godot API assemblies: " + debugApiAssembliesError);
-                        return false;
-                    }
-
-                    string releaseApiAssembliesError = Internal.UpdateApiAssembliesFromPrebuilt("Release");
-
-                    if (!string.IsNullOrEmpty(releaseApiAssembliesError))
-                    {
-                        ShowErrorDialog("Failed to update the Godot API assemblies: " + releaseApiAssembliesError);
-                        return false;
-                    }
-
                     pr.Step("Done".TTR());
 
                     // Here, after all calls to progress_task_step
@@ -533,8 +515,9 @@ namespace GodotTools
         public static GodotSharpEditor Instance { get; private set; }
 
         [UsedImplicitly]
-        private GodotSharpEditor()
+        private static IntPtr InternalCreateInstance()
         {
+            return new GodotSharpEditor().NativeInstance;
         }
     }
 }
diff --git a/modules/mono/editor/GodotTools/GodotTools/GodotTools.csproj b/modules/mono/editor/GodotTools/GodotTools/GodotTools.csproj
index f1d45463c5..d44cd75155 100644
--- a/modules/mono/editor/GodotTools/GodotTools/GodotTools.csproj
+++ b/modules/mono/editor/GodotTools/GodotTools/GodotTools.csproj
@@ -2,12 +2,13 @@
   <PropertyGroup>
     <ProjectGuid>{27B00618-A6F2-4828-B922-05CAEB08C286}</ProjectGuid>
     <TargetFramework>net472</TargetFramework>
-    <LangVersion>7.2</LangVersion>
+    <LangVersion>8</LangVersion>
     <!-- The Godot editor uses the Debug Godot API assemblies -->
     <GodotApiConfiguration>Debug</GodotApiConfiguration>
     <GodotSourceRootPath>$(SolutionDir)/../../../../</GodotSourceRootPath>
     <GodotOutputDataDir>$(GodotSourceRootPath)/bin/GodotSharp</GodotOutputDataDir>
     <GodotApiAssembliesDir>$(GodotOutputDataDir)/Api/$(GodotApiConfiguration)</GodotApiAssembliesDir>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup Condition=" Exists('$(GodotApiAssembliesDir)/GodotSharp.dll') ">
     <!-- The project is part of the Godot source tree -->
diff --git a/modules/mono/editor/GodotTools/GodotTools/Internals/EditorProgress.cs b/modules/mono/editor/GodotTools/GodotTools/Internals/EditorProgress.cs
index 70ba7c733a..b221ae7c5c 100644
--- a/modules/mono/editor/GodotTools/GodotTools/Internals/EditorProgress.cs
+++ b/modules/mono/editor/GodotTools/GodotTools/Internals/EditorProgress.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Runtime.CompilerServices;
 using Godot;
+using Godot.NativeInterop;
 
 namespace GodotTools.Internals
 {
@@ -9,18 +10,22 @@ namespace GodotTools.Internals
         public string Task { get; }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void internal_Create(string task, string label, int amount, bool canCancel);
+        private static extern void internal_Create(in godot_string task, in godot_string label, int amount,
+            bool canCancel);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void internal_Dispose(string task);
+        private static extern void internal_Dispose(in godot_string task);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool internal_Step(string task, string state, int step, bool forceRefresh);
+        private static extern bool internal_Step(in godot_string task, in godot_string state, int step,
+            bool forceRefresh);
 
         public EditorProgress(string task, string label, int amount, bool canCancel = false)
         {
             Task = task;
-            internal_Create(task, label, amount, canCancel);
+            using godot_string taskIn = Marshaling.mono_string_to_godot(task);
+            using godot_string labelIn = Marshaling.mono_string_to_godot(label);
+            internal_Create(taskIn, labelIn, amount, canCancel);
         }
 
         ~EditorProgress()
@@ -33,18 +38,23 @@ namespace GodotTools.Internals
 
         public void Dispose()
         {
-            internal_Dispose(Task);
+            using godot_string taskIn = Marshaling.mono_string_to_godot(Task);
+            internal_Dispose(taskIn);
             GC.SuppressFinalize(this);
         }
 
         public void Step(string state, int step = -1, bool forceRefresh = true)
         {
-            internal_Step(Task, state, step, forceRefresh);
+            using godot_string taskIn = Marshaling.mono_string_to_godot(Task);
+            using godot_string stateIn = Marshaling.mono_string_to_godot(state);
+            internal_Step(taskIn, stateIn, step, forceRefresh);
         }
 
         public bool TryStep(string state, int step = -1, bool forceRefresh = true)
         {
-            return internal_Step(Task, state, step, forceRefresh);
+            using godot_string taskIn = Marshaling.mono_string_to_godot(Task);
+            using godot_string stateIn = Marshaling.mono_string_to_godot(state);
+            return internal_Step(taskIn, stateIn, step, forceRefresh);
         }
     }
 }
diff --git a/modules/mono/editor/GodotTools/GodotTools/Internals/Globals.cs b/modules/mono/editor/GodotTools/GodotTools/Internals/Globals.cs
index 5c5ced8c29..d79821de3c 100644
--- a/modules/mono/editor/GodotTools/GodotTools/Internals/Globals.cs
+++ b/modules/mono/editor/GodotTools/GodotTools/Internals/Globals.cs
@@ -1,3 +1,4 @@
+using Godot.NativeInterop;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
@@ -7,17 +8,40 @@ namespace GodotTools.Internals
     {
         public static float EditorScale => internal_EditorScale();
 
-        public static object GlobalDef(string setting, object defaultValue, bool restartIfChanged = false) =>
-            internal_GlobalDef(setting, defaultValue, restartIfChanged);
+        public static unsafe object GlobalDef(string setting, object defaultValue, bool restartIfChanged = false)
+        {
+            using godot_string settingIn = Marshaling.mono_string_to_godot(setting);
+            using godot_variant defaultValueIn = Marshaling.mono_object_to_variant(defaultValue);
+            internal_GlobalDef(settingIn, defaultValueIn, restartIfChanged, out godot_variant result);
+            using (result)
+                return Marshaling.variant_to_mono_object(&result);
+        }
 
-        public static object EditorDef(string setting, object defaultValue, bool restartIfChanged = false) =>
-            internal_EditorDef(setting, defaultValue, restartIfChanged);
+        public static unsafe object EditorDef(string setting, object defaultValue, bool restartIfChanged = false)
+        {
+            using godot_string settingIn = Marshaling.mono_string_to_godot(setting);
+            using godot_variant defaultValueIn = Marshaling.mono_object_to_variant(defaultValue);
+            internal_EditorDef(settingIn, defaultValueIn, restartIfChanged, out godot_variant result);
+            using (result)
+                return Marshaling.variant_to_mono_object(&result);
+        }
 
-        public static object EditorShortcut(string setting) =>
-            internal_EditorShortcut(setting);
+        public static unsafe object EditorShortcut(string setting)
+        {
+            using godot_string settingIn = Marshaling.mono_string_to_godot(setting);
+            internal_EditorShortcut(settingIn, out godot_variant result);
+            using (result)
+                return Marshaling.variant_to_mono_object(&result);
+        }
 
         [SuppressMessage("ReSharper", "InconsistentNaming")]
-        public static string TTR(this string text) => internal_TTR(text);
+        public static string TTR(this string text)
+        {
+            using godot_string textIn = Marshaling.mono_string_to_godot(text);
+            internal_TTR(textIn, out godot_string dest);
+            using (dest)
+                return Marshaling.mono_string_from_godot(dest);
+        }
 
         // Internal Calls
 
@@ -25,15 +49,17 @@ namespace GodotTools.Internals
         private static extern float internal_EditorScale();
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern object internal_GlobalDef(string setting, object defaultValue, bool restartIfChanged);
+        private static extern void internal_GlobalDef(in godot_string setting, in godot_variant defaultValue,
+            bool restartIfChanged, out godot_variant result);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern object internal_EditorDef(string setting, object defaultValue, bool restartIfChanged);
+        private static extern void internal_EditorDef(in godot_string setting, in godot_variant defaultValue,
+            bool restartIfChanged, out godot_variant result);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern object internal_EditorShortcut(string setting);
+        private static extern void internal_EditorShortcut(in godot_string setting, out godot_variant result);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_TTR(string text);
+        private static extern void internal_TTR(in godot_string text, out godot_string dest);
     }
 }
diff --git a/modules/mono/editor/GodotTools/GodotTools/Internals/GodotSharpDirs.cs b/modules/mono/editor/GodotTools/GodotTools/Internals/GodotSharpDirs.cs
index 5e70c399b2..b15ebc1ae2 100644
--- a/modules/mono/editor/GodotTools/GodotTools/Internals/GodotSharpDirs.cs
+++ b/modules/mono/editor/GodotTools/GodotTools/Internals/GodotSharpDirs.cs
@@ -1,102 +1,102 @@
 using System.Runtime.CompilerServices;
+using Godot.NativeInterop;
 
 namespace GodotTools.Internals
 {
     public static class GodotSharpDirs
     {
-        public static string ResDataDir => internal_ResDataDir();
-        public static string ResMetadataDir => internal_ResMetadataDir();
-        public static string ResAssembliesBaseDir => internal_ResAssembliesBaseDir();
-        public static string ResAssembliesDir => internal_ResAssembliesDir();
-        public static string ResConfigDir => internal_ResConfigDir();
-        public static string ResTempDir => internal_ResTempDir();
-        public static string ResTempAssembliesBaseDir => internal_ResTempAssembliesBaseDir();
-        public static string ResTempAssembliesDir => internal_ResTempAssembliesDir();
-
-        public static string MonoUserDir => internal_MonoUserDir();
-        public static string MonoLogsDir => internal_MonoLogsDir();
-
-        #region Tools-only
-        public static string MonoSolutionsDir => internal_MonoSolutionsDir();
-        public static string BuildLogsDirs => internal_BuildLogsDirs();
-
-        public static string ProjectSlnPath => internal_ProjectSlnPath();
-        public static string ProjectCsProjPath => internal_ProjectCsProjPath();
-
-        public static string DataEditorToolsDir => internal_DataEditorToolsDir();
-        public static string DataEditorPrebuiltApiDir => internal_DataEditorPrebuiltApiDir();
-        #endregion
-
-        public static string DataMonoEtcDir => internal_DataMonoEtcDir();
-        public static string DataMonoLibDir => internal_DataMonoLibDir();
-
-        #region Windows-only
-        public static string DataMonoBinDir => internal_DataMonoBinDir();
-        #endregion
-
+        public static string ResMetadataDir
+        {
+            get
+            {
+                internal_ResMetadataDir(out godot_string dest);
+                using (dest)
+                    return Marshaling.mono_string_from_godot(dest);
+            }
+        }
+
+        public static string ResTempAssembliesBaseDir
+        {
+            get
+            {
+                internal_ResTempAssembliesBaseDir(out godot_string dest);
+                using (dest)
+                    return Marshaling.mono_string_from_godot(dest);
+            }
+        }
+
+        public static string MonoUserDir
+        {
+            get
+            {
+                internal_MonoUserDir(out godot_string dest);
+                using (dest)
+                    return Marshaling.mono_string_from_godot(dest);
+            }
+        }
+
+        public static string BuildLogsDirs
+        {
+            get
+            {
+                internal_BuildLogsDirs(out godot_string dest);
+                using (dest)
+                    return Marshaling.mono_string_from_godot(dest);
+            }
+        }
+
+        public static string ProjectSlnPath
+        {
+            get
+            {
+                internal_ProjectSlnPath(out godot_string dest);
+                using (dest)
+                    return Marshaling.mono_string_from_godot(dest);
+            }
+        }
+
+        public static string ProjectCsProjPath
+        {
+            get
+            {
+                internal_ProjectCsProjPath(out godot_string dest);
+                using (dest)
+                    return Marshaling.mono_string_from_godot(dest);
+            }
+        }
+
+        public static string DataEditorToolsDir
+        {
+            get
+            {
+                internal_DataEditorToolsDir(out godot_string dest);
+                using (dest)
+                    return Marshaling.mono_string_from_godot(dest);
+            }
+        }
 
         #region Internal
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_ResDataDir();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_ResMetadataDir();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_ResAssembliesBaseDir();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_ResAssembliesDir();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_ResConfigDir();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_ResTempDir();
+        private static extern void internal_ResMetadataDir(out godot_string r_dest);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_ResTempAssembliesBaseDir();
+        private static extern void internal_ResTempAssembliesBaseDir(out godot_string r_dest);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_ResTempAssembliesDir();
+        private static extern void internal_MonoUserDir(out godot_string r_dest);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_MonoUserDir();
+        private static extern void internal_BuildLogsDirs(out godot_string r_dest);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_MonoLogsDir();
+        private static extern void internal_ProjectSlnPath(out godot_string r_dest);
 
-        #region Tools-only
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_MonoSolutionsDir();
+        private static extern void internal_ProjectCsProjPath(out godot_string r_dest);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_BuildLogsDirs();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_ProjectSlnPath();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_ProjectCsProjPath();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_DataEditorToolsDir();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_DataEditorPrebuiltApiDir();
-        #endregion
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_DataMonoEtcDir();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_DataMonoLibDir();
-
-        #region Windows-only
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_DataMonoBinDir();
-        #endregion
+        private static extern void internal_DataEditorToolsDir(out godot_string r_dest);
 
         #endregion
     }
diff --git a/modules/mono/editor/GodotTools/GodotTools/Internals/Internal.cs b/modules/mono/editor/GodotTools/GodotTools/Internals/Internal.cs
index 12c90178c9..7ba26939fa 100644
--- a/modules/mono/editor/GodotTools/GodotTools/Internals/Internal.cs
+++ b/modules/mono/editor/GodotTools/GodotTools/Internals/Internal.cs
@@ -1,5 +1,7 @@
+using System;
 using System.Runtime.CompilerServices;
 using Godot;
+using Godot.NativeInterop;
 using GodotTools.IdeMessaging.Requests;
 
 namespace GodotTools.Internals
@@ -9,15 +11,23 @@ namespace GodotTools.Internals
         public const string CSharpLanguageType = "CSharpScript";
         public const string CSharpLanguageExtension = ".cs";
 
-        public static string UpdateApiAssembliesFromPrebuilt(string config) =>
-            internal_UpdateApiAssembliesFromPrebuilt(config);
+        public static string FullExportTemplatesDir
+        {
+            get
+            {
+                internal_FullExportTemplatesDir(out godot_string dest);
+                using (dest)
+                    return Marshaling.mono_string_from_godot(dest);
+            }
+        }
 
-        public static string FullExportTemplatesDir =>
-            internal_FullExportTemplatesDir();
+        public static string SimplifyGodotPath(this string path) => Godot.StringExtensions.SimplifyPath(path);
 
-        public static string SimplifyGodotPath(this string path) => internal_SimplifyGodotPath(path);
-
-        public static bool IsMacOSAppBundleInstalled(string bundleId) => internal_IsMacOSAppBundleInstalled(bundleId);
+        public static bool IsMacOSAppBundleInstalled(string bundleId)
+        {
+            using godot_string bundleIdIn = Marshaling.mono_string_to_godot(bundleId);
+            return internal_IsMacOSAppBundleInstalled(bundleIdIn);
+        }
 
         public static bool GodotIs32Bits() => internal_GodotIs32Bits();
 
@@ -25,10 +35,6 @@ namespace GodotTools.Internals
 
         public static void GodotMainIteration() => internal_GodotMainIteration();
 
-        public static ulong GetCoreApiHash() => internal_GetCoreApiHash();
-
-        public static ulong GetEditorApiHash() => internal_GetEditorApiHash();
-
         public static bool IsAssembliesReloadingNeeded() => internal_IsAssembliesReloadingNeeded();
 
         public static void ReloadAssemblies(bool softReload) => internal_ReloadAssemblies(softReload);
@@ -36,11 +42,19 @@ namespace GodotTools.Internals
         public static void EditorDebuggerNodeReloadScripts() => internal_EditorDebuggerNodeReloadScripts();
 
         public static bool ScriptEditorEdit(Resource resource, int line, int col, bool grabFocus = true) =>
-            internal_ScriptEditorEdit(resource, line, col, grabFocus);
+            internal_ScriptEditorEdit(resource.NativeInstance, line, col, grabFocus);
 
         public static void EditorNodeShowScriptScreen() => internal_EditorNodeShowScriptScreen();
 
-        public static string MonoWindowsInstallRoot => internal_MonoWindowsInstallRoot();
+        public static string MonoWindowsInstallRoot
+        {
+            get
+            {
+                internal_MonoWindowsInstallRoot(out godot_string dest);
+                using (dest)
+                    return Marshaling.mono_string_from_godot(dest);
+            }
+        }
 
         public static void EditorRunPlay() => internal_EditorRunPlay();
 
@@ -48,22 +62,22 @@ namespace GodotTools.Internals
 
         public static void ScriptEditorDebugger_ReloadScripts() => internal_ScriptEditorDebugger_ReloadScripts();
 
-        public static string[] CodeCompletionRequest(CodeCompletionRequest.CompletionKind kind, string scriptFile) =>
-            internal_CodeCompletionRequest((int)kind, scriptFile);
+        public static unsafe string[] CodeCompletionRequest(CodeCompletionRequest.CompletionKind kind,
+            string scriptFile)
+        {
+            using godot_string scriptFileIn = Marshaling.mono_string_to_godot(scriptFile);
+            internal_CodeCompletionRequest((int)kind, scriptFileIn, out godot_packed_string_array res);
+            using (res)
+                return Marshaling.PackedStringArray_to_mono_array(&res);
+        }
 
         #region Internal
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_UpdateApiAssembliesFromPrebuilt(string config);
+        private static extern void internal_FullExportTemplatesDir(out godot_string dest);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_FullExportTemplatesDir();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_SimplifyGodotPath(this string path);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool internal_IsMacOSAppBundleInstalled(string bundleId);
+        private static extern bool internal_IsMacOSAppBundleInstalled(in godot_string bundleId);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern bool internal_GodotIs32Bits();
@@ -75,12 +89,6 @@ namespace GodotTools.Internals
         private static extern void internal_GodotMainIteration();
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern ulong internal_GetCoreApiHash();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern ulong internal_GetEditorApiHash();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern bool internal_IsAssembliesReloadingNeeded();
 
         [MethodImpl(MethodImplOptions.InternalCall)]
@@ -90,13 +98,13 @@ namespace GodotTools.Internals
         private static extern void internal_EditorDebuggerNodeReloadScripts();
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool internal_ScriptEditorEdit(Resource resource, int line, int col, bool grabFocus);
+        private static extern bool internal_ScriptEditorEdit(IntPtr resource, int line, int col, bool grabFocus);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void internal_EditorNodeShowScriptScreen();
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string internal_MonoWindowsInstallRoot();
+        private static extern void internal_MonoWindowsInstallRoot(out godot_string dest);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void internal_EditorRunPlay();
@@ -108,7 +116,8 @@ namespace GodotTools.Internals
         private static extern void internal_ScriptEditorDebugger_ReloadScripts();
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string[] internal_CodeCompletionRequest(int kind, string scriptFile);
+        private static extern void internal_CodeCompletionRequest(int kind, in godot_string scriptFile,
+            out godot_packed_string_array res);
 
         #endregion
     }
diff --git a/modules/mono/editor/GodotTools/GodotTools/Utils/OS.cs b/modules/mono/editor/GodotTools/GodotTools/Utils/OS.cs
index 5cef6e5c3c..aa100433c9 100644
--- a/modules/mono/editor/GodotTools/GodotTools/Utils/OS.cs
+++ b/modules/mono/editor/GodotTools/GodotTools/Utils/OS.cs
@@ -1,3 +1,4 @@
+using Godot.NativeInterop;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -13,10 +14,10 @@ namespace GodotTools.Utils
     public static class OS
     {
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern string GetPlatformName();
+        private static extern void GetPlatformName(out godot_string dest);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool UnixFileHasExecutableAccess(string filePath);
+        private static extern bool UnixFileHasExecutableAccess(in godot_string filePath);
 
         public static class Names
         {
@@ -63,14 +64,24 @@ namespace GodotTools.Utils
             [Names.HTML5] = Platforms.HTML5
         };
 
-        private static bool IsOS(string name)
+        private static unsafe bool IsOS(string name)
         {
-            return name.Equals(GetPlatformName(), StringComparison.OrdinalIgnoreCase);
+            GetPlatformName(out godot_string dest);
+            using (dest)
+            {
+                string platformName = Marshaling.mono_string_from_godot(dest);
+                return name.Equals(platformName, StringComparison.OrdinalIgnoreCase);
+            }
         }
 
-        private static bool IsAnyOS(IEnumerable<string> names)
+        private static unsafe bool IsAnyOS(IEnumerable<string> names)
         {
-            return names.Any(p => p.Equals(GetPlatformName(), StringComparison.OrdinalIgnoreCase));
+            GetPlatformName(out godot_string dest);
+            using (dest)
+            {
+                string platformName = Marshaling.mono_string_from_godot(dest);
+                return names.Any(p => p.Equals(platformName, StringComparison.OrdinalIgnoreCase));
+            }
         }
 
         private static readonly IEnumerable<string> LinuxBSDPlatforms =
@@ -114,7 +125,8 @@ namespace GodotTools.Utils
 
         private static string PathWhichWindows([NotNull] string name)
         {
-            string[] windowsExts = Environment.GetEnvironmentVariable("PATHEXT")?.Split(PathSep) ?? Array.Empty<string>();
+            string[] windowsExts =
+                Environment.GetEnvironmentVariable("PATHEXT")?.Split(PathSep) ?? Array.Empty<string>();
             string[] pathDirs = Environment.GetEnvironmentVariable("PATH")?.Split(PathSep);
             char[] invalidPathChars = Path.GetInvalidPathChars();
 
@@ -141,10 +153,10 @@ namespace GodotTools.Utils
                 return searchDirs.Select(dir => Path.Combine(dir, name)).FirstOrDefault(File.Exists);
 
             return (from dir in searchDirs
-                    select Path.Combine(dir, name)
+                select Path.Combine(dir, name)
                 into path
-                    from ext in windowsExts
-                    select path + ext).FirstOrDefault(File.Exists);
+                from ext in windowsExts
+                select path + ext).FirstOrDefault(File.Exists);
         }
 
         private static string PathWhichUnix([NotNull] string name)
@@ -168,7 +180,11 @@ namespace GodotTools.Utils
             searchDirs.Add(System.IO.Directory.GetCurrentDirectory()); // last in the list
 
             return searchDirs.Select(dir => Path.Combine(dir, name))
-                .FirstOrDefault(path => File.Exists(path) && UnixFileHasExecutableAccess(path));
+                .FirstOrDefault(path =>
+                {
+                    using godot_string pathIn = Marshaling.mono_string_to_godot(path);
+                    return File.Exists(path) && UnixFileHasExecutableAccess(pathIn);
+                });
         }
 
         public static void RunProcess(string command, IEnumerable<string> arguments)