feat: Property support properties in derived classes

Previously, we weren't scanning parent classes for properties. Now we are.

Additionally, add a super secret hidden property that adds the name of the class instead of the script file as the category header.

Author: fuzzybinary

src/cpp/script/dart_script.cpp

@@ -216,19 +216,23 @@ godot::TypedArray<godot::Dictionary> DartScript::_get_script_property_list() con
 
   godot::TypedArray<godot::Dictionary> ret_val;
 
-  // TODO: Look if there's a better way to store these strings as constants
-  for (const auto &prop : _properties_cache) {
-    const auto &prop_info = prop.second;
-    godot::Dictionary info_dict;
-    info_dict[godot::Variant(godot::String("type"))] = Variant(prop_info.type);
-    info_dict[godot::Variant(godot::String("name"))] = Variant(*reinterpret_cast<godot::String *>(prop_info.name));
-    info_dict[godot::Variant(godot::String("class_name"))] =
-        Variant(*reinterpret_cast<godot::StringName *>(prop_info.name));
-    info_dict[godot::Variant(godot::String("hint"))] = Variant(prop_info.hint);
-    info_dict[godot::Variant(godot::String("hint_string"))] =
-        Variant(*reinterpret_cast<godot::String *>(prop_info.hint_string));
-    info_dict[godot::Variant(godot::String("usage"))] = Variant(prop_info.usage);
-    ret_val.push_back(info_dict);
+  const DartScript *top = this;
+  while (top != nullptr) {
+    const auto &properties_cache = top->get_properties();
+    for (const auto &prop_info : properties_cache) {
+      godot::Dictionary info_dict;
+      info_dict[godot::Variant(godot::String("type"))] = Variant(prop_info.type);
+      info_dict[godot::Variant(godot::String("name"))] =
+          Variant(*reinterpret_cast<godot::StringName *>(prop_info.name));
+      info_dict[godot::Variant(godot::String("class_name"))] =
+          Variant(*reinterpret_cast<godot::StringName *>(prop_info.class_name));
+      info_dict[godot::Variant(godot::String("hint"))] = Variant(prop_info.hint);
+      info_dict[godot::Variant(godot::String("hint_string"))] =
+          Variant(*reinterpret_cast<godot::String *>(prop_info.hint_string));
+      info_dict[godot::Variant(godot::String("usage"))] = Variant(prop_info.usage);
+      ret_val.push_back(info_dict);
+    }
+    top = top->_base_script.ptr();
   }
 
   return ret_val;
@@ -433,7 +437,7 @@ void DartScript::dart_placeholder_erased(DartScriptInstance *p_placeholder) {
 
 void DartScript::clear_property_cache() {
   for (auto &prop : _properties_cache) {
-    gde_free_property_info_fields(&prop.second);
+    gde_free_property_info_fields(&prop);
   }
   _properties_cache.clear();
 }
@@ -495,13 +499,27 @@ void DartScript::refresh_type(bool force) {
         intptr_t prop_count = 0;
         Dart_ListLength(properties_list, &prop_count);
 
+        // Always add a secret hidden property that tells Godot the name of our class
+        {
+          DART_CHECK(class_name, Dart_GetField(type_info, Dart_NewStringFromCString("className")),
+                     "Failed to get class name.");
+          GDExtensionPropertyInfo property_info = {
+              GDEXTENSION_VARIANT_TYPE_NIL,
+              new godot::StringName(*reinterpret_cast<godot::StringName *>(get_object_address(class_name))),
+              new godot::String(),
+              PROPERTY_HINT_NONE,
+              new godot::String(path),
+              PROPERTY_USAGE_CATEGORY};
+          _properties_cache.push_back(property_info);
+        }
+
         if (prop_count > 0) {
           for (auto i = 0; i < prop_count; ++i) {
             DART_CHECK(dart_property, Dart_ListGetAt(properties_list, i), "Failed to get property at index");
             GDExtensionPropertyInfo property_info;
             gde_property_info_from_dart(dart_property, &property_info);
             godot::StringName *prop_name = reinterpret_cast<godot::StringName *>(property_info.name);
-            _properties_cache[*prop_name] = property_info;
+            _properties_cache.push_back(property_info);
           }
         }
 

src/cpp/script/dart_script.h

@@ -52,13 +52,16 @@ class DartScript : public godot::ScriptExtension {
   void *_instance_create(Object *for_object) const override;
   void *_placeholder_instance_create(Object *for_object) const override;
 
-  const std::unordered_map<godot::StringName, GDExtensionPropertyInfo> &get_properties() const {
+  const std::vector<GDExtensionPropertyInfo> &get_properties() const {
     return _properties_cache;
   }
 
   // Create the Dart object represented by this script
   Dart_Handle create_dart_object(Object *for_object);
   Dart_Handle get_dart_type_info();
+  godot::Ref<DartScript> get_base_dart_script() {
+    return _base_script;
+  }
 
   // ScriptInstances in extensions are never of the type that calls
   // _placeholder_erased, so we handle this manually on instance free
@@ -73,7 +76,7 @@ class DartScript : public godot::ScriptExtension {
   void *create_script_instance_internal(Object *for_object, bool is_placeholder) const;
 
   godot::String _source_code;
-  std::unordered_map<godot::StringName, GDExtensionPropertyInfo> _properties_cache;
+  std::vector<GDExtensionPropertyInfo> _properties_cache;
   godot::Variant _rpc_config;
 
   mutable std::unordered_set<DartScriptInstance *> _placeholders;

src/cpp/script/dart_script_instance.cpp

@@ -1,5 +1,7 @@
 #include "dart_script_instance.h"
 
+#include <algorithm>
+
 #include <dart_api.h>
 
 #include <godot_cpp/classes/object.hpp>
@@ -163,15 +165,32 @@ bool DartScriptInstance::get_class_category(GDExtensionPropertyInfo *p_class_cat
 
 const GDExtensionPropertyInfo *DartScriptInstance::get_property_list(uint32_t *r_count) {
   GDExtensionPropertyInfo *prop_list{nullptr};
-  const auto &prop_map = _dart_script->get_properties();
-  size_t prop_count = prop_map.size();
+
+  // First scan to get total size
+  size_t prop_count = 0;
+  {
+    DartScript *top = _dart_script.ptr();
+    while (top != nullptr) {
+      const auto &properties = top->get_properties();
+      prop_count += properties.size();
+
+      top = top->get_base_dart_script().ptr();
+    }
+  }
+
   *r_count = prop_count;
   if (prop_count > 0) {
+    // Now get all the properties
     prop_list = new GDExtensionPropertyInfo[prop_count];
     size_t index = 0;
-    for (const auto &property : prop_map) {
-      prop_list[index] = property.second;
-      ++index;
+    DartScript *top = _dart_script.ptr();
+    while (top != nullptr) {
+      const auto &properties = top->get_properties();
+      for (const auto &property_info : properties) {
+        prop_list[index] = property_info;
+        ++index;
+      }
+      top = top->get_base_dart_script().ptr();
     }
   }
 
@@ -184,11 +203,19 @@ void DartScriptInstance::free_property_list(const GDExtensionPropertyInfo *p_lis
 
 GDExtensionVariantType DartScriptInstance::get_property_type(const godot::StringName &p_name,
                                                              GDExtensionBool *r_is_valid) {
-  const auto &properties = _dart_script->get_properties();
-  const auto &prop_itr = properties.find(p_name);
-  *r_is_valid = prop_itr != properties.end();
-  if (r_is_valid) {
-    return prop_itr->second.type;
+
+  DartScript *top = _dart_script.ptr();
+  while (top != nullptr) {
+    const auto &properties = top->get_properties();
+    const auto &prop_itr = std::find_if(properties.begin(), properties.end(), [&](auto &e) {
+      godot::StringName name(*reinterpret_cast<godot::StringName *>(e.name));
+      return name == p_name;
+    });
+    *r_is_valid = prop_itr != properties.end();
+    if (r_is_valid) {
+      return prop_itr->type;
+    }
+    top = top->get_base_dart_script().ptr();
   }
   return GDExtensionVariantType{};
 }

src/dart/godot_dart/lib/src/core/type_info.dart

@@ -394,6 +394,17 @@ class ExtensionTypeInfo<T> implements TypeInfo {
 
   @pragma('vm:entry-point')
   PropertyInfo? getPropertyInfo(String propertyName) {
-    return properties.firstWhereOrNull((e) => e.name == propertyName);
+    ExtensionTypeInfo<dynamic>? searchTypeInfo = this;
+    PropertyInfo? info;
+    while (searchTypeInfo != null &&
+        searchTypeInfo.className != searchTypeInfo.nativeTypeName) {
+      info = searchTypeInfo.properties
+          .firstWhereOrNull((e) => e.name == propertyName);
+      if (info != null) {
+        break;
+      }
+      searchTypeInfo = searchTypeInfo.parentTypeInfo;
+    }
+    return info;
   }
 }