applying more PR feedback

Author: ogapo

godot-codegen/src/special_cases/codegen_special_cases.rs

@@ -140,7 +140,6 @@ const SELECTED_CLASSES: &[&str] = &[
     "ClassDB",
     "Engine",
     "OS",
-    "ProjectSettings",
     //
     // Editor plugins
     "EditorPlugin",

godot-codegen/src/special_cases/special_cases.rs

@@ -1003,7 +1003,7 @@ pub fn get_derived_virtual_method_presence(class_name: &TyName, godot_method_nam
 ///   - register_server_singletons() ...another weird one.
 ///   - Autoloads, etc.
 #[rustfmt::skip]
-pub fn classify_codegen_level(class_name: &str, godot_classification: &str) -> Option<ClassCodegenLevel> {
+pub fn classify_codegen_level(class_name: &str) -> Option<ClassCodegenLevel> {
     let level = match class_name {
         // See register_core_types() in https://github.com/godotengine/godot/blob/master/core/register_core_types.cpp,
         // which is called before Core level is initialized.
@@ -1017,8 +1017,8 @@ pub fn classify_codegen_level(class_name: &str, godot_classification: &str) -> O
         | "ProjectSettings" | "Engine" | "OS" | "Time"
         => ClassCodegenLevel::Core,
 
-        // Anything that comes from another extension could be available in Core but since there would be load order dependencies,
-        // instead don't allow calls until Server level.
+        // Symbols from another extension could be available in Core, but since GDExtension can currently not guarantee
+        // the order of different extensions being loaded, we prevent implicit dependencies and require Server.
         | "OpenXRExtensionWrapperExtension" 
         => ClassCodegenLevel::Servers,
 
@@ -1050,18 +1050,8 @@ pub fn classify_codegen_level(class_name: &str, godot_classification: &str) -> O
         "ResourceImporterOggVorbis" | "ResourceImporterMP3" if cfg!(before_api = "4.3") 
         => ClassCodegenLevel::Editor,
 
-        _ => {
-            // NOTE: Right now, Godot reports everything that's not "editor" as "core" in `extension_api.json`. 
-            // If it wasn't picked up by the whitelist, and Godot reports it as "core" we will treat it as a scene class.
-            match godot_classification {
-                "editor" => ClassCodegenLevel::Editor,
-                "core" => ClassCodegenLevel::Scene,
-                _ => {
-                    // we don't know this classification
-                    return None;
-                }
-            }
-        }
+        // No special-case override for this class.
+        _ => return None,
     };
     Some(level)
 }

godot-codegen/src/util.rs

@@ -53,22 +53,25 @@ pub fn make_sname_ptr(identifier: &str) -> TokenStream {
 pub fn get_api_level(class: &JsonClass) -> ClassCodegenLevel {
     // NOTE: We have to use a whitelist of known classes because Godot doesn't separate these out
     // beyond "editor" and "core" and some classes are also  mis-classified in the JSON depending on the Godot version.
-    if let Some(forced_classification) =
-        special_cases::classify_codegen_level(&class.name, &class.api_type)
-    {
+    if let Some(forced_classification) = special_cases::classify_codegen_level(&class.name) {
         return forced_classification;
     }
 
-    // Fall back to just trusting the categorization. Presently, Godot only reports "core" and "editor".
-    for level in ClassCodegenLevel::with_tables() {
-        if level.lower() == class.api_type {
-            return level;
+    // NOTE: Right now, Godot reports everything that's not "editor" as "core" in `extension_api.json`.
+    // If it wasn't picked up by classify_codegen_level, and Godot reports it as "core" we will treat it as a scene class.
+    match class.api_type.as_str() {
+        "editor" => ClassCodegenLevel::Editor,
+        "core" => ClassCodegenLevel::Scene,
+        "extension" => ClassCodegenLevel::Scene,
+        "editor_extension" => ClassCodegenLevel::Editor,
+        _ => {
+            // we don't know this classification
+            panic!(
+                "class {} has unknown API type {}",
+                class.name, class.api_type
+            );
         }
     }
-    panic!(
-        "class {} has unknown API type {}",
-        class.name, class.api_type
-    );
 }
 
 pub fn ident(s: &str) -> Ident {

itest/rust/src/lib.rs

@@ -5,9 +5,8 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use std::sync::Mutex;
-
 use godot::init::{gdextension, ExtensionLibrary, InitLevel};
+use godot::sys::Global;
 
 mod benchmarks;
 mod builtin_tests;
@@ -20,22 +19,25 @@ mod register_tests;
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Entry point
 
-static LEVELS_SEEN: Mutex<Vec<InitLevel>> = Mutex::new(Vec::new());
+static LEVELS_SEEN: Global<Vec<InitLevel>> = Global::default();
 
 #[gdextension(entry_symbol = itest_init)]
 unsafe impl ExtensionLibrary for framework::IntegrationTests {
     fn min_level() -> InitLevel {
         InitLevel::Core
     }
     fn on_level_init(level: InitLevel) {
-        LEVELS_SEEN.lock().unwrap().push(level);
+        LEVELS_SEEN.lock().push(level);
         match level {
             InitLevel::Core => {
-                // make sure we can access early core singletons
+                // Make sure we can access early core singletons.
                 object_tests::test_early_core_singletons();
             }
             InitLevel::Servers => {}
-            InitLevel::Scene => {}
+            InitLevel::Scene => {
+                // Make sure we can access server singletons by now.
+                object_tests::test_general_singletons();
+            }
             InitLevel::Editor => {}
         }
     }
@@ -44,7 +46,7 @@ unsafe impl ExtensionLibrary for framework::IntegrationTests {
 // Ensure that we saw all the init levels expected.
 #[crate::framework::itest]
 fn observed_all_init_levels() {
-    let levels_seen = LEVELS_SEEN.lock().unwrap().clone();
+    let levels_seen = LEVELS_SEEN.lock().clone();
     assert_eq!(levels_seen[0], InitLevel::Core);
     assert_eq!(levels_seen[1], InitLevel::Servers);
     assert_eq!(levels_seen[2], InitLevel::Scene);

itest/rust/src/object_tests/init_level_test.rs

@@ -34,14 +34,20 @@ impl SomeObject {
     }
 }
 
-// Run during core init level to ensure we can access core singletons.
+// Runs during core init level to ensure we can access core singletons.
 pub fn test_early_core_singletons() {
-    // ensure we can create and use an Object-derived class during Core init level.
+    // Ensure we can create and use an Object-derived class during Core init level.
     SomeObject::test();
 
-    // check the early core singletons we can access here.
-    let project_settings = godot::classes::ProjectSettings::singleton();
-    project_settings.get("application/config/name");
+    // Check the early core singletons we can access here.
+    #[cfg(feature = "codegen-full")]
+    {
+        let project_settings = godot::classes::ProjectSettings::singleton();
+        assert_eq!(
+            project_settings.get("application/config/name").get_type(),
+            godot::builtin::VariantType::STRING
+        );
+    }
 
     let engine = godot::classes::Engine::singleton();
     assert!(engine.get_physics_ticks_per_second() > 0);
@@ -53,6 +59,12 @@ pub fn test_early_core_singletons() {
     assert!(time.get_ticks_usec() <= time.get_ticks_usec());
 }
 
+// Runs during scene init level to ensure we can access general singletons in the Scene init call for the extension as a whole.
+pub fn test_general_singletons() {
+    let mut rendering = godot::classes::RenderingServer::singleton();
+    assert!(rendering.get_test_cube() != godot::builtin::Rid::Invalid);
+}
+
 // Ensure that the above function actually ran.
 #[itest]
 fn class_run_during_servers_init() {

itest/rust/src/object_tests/mod.rs

@@ -33,4 +33,4 @@ mod virtual_methods_niche_test;
 mod virtual_methods_test;
 
 // Need to test this in the init level method.
-pub use init_level_test::test_early_core_singletons;
+pub use init_level_test::*;