Implement typed dictionaries

Author: Repiteo

binding_generator.py

@@ -421,6 +421,8 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl
     for include in fully_used_classes:
         if include == "TypedArray":
             result.append("#include <godot_cpp/variant/typed_array.hpp>")
+        elif include == "TypedDictionary":
+            result.append("#include <godot_cpp/variant/typed_dictionary.hpp>")
         else:
             result.append(f"#include <godot_cpp/{get_include_path(include)}>")
 
@@ -743,6 +745,10 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl
     if class_name == "Dictionary":
         result.append("\tconst Variant &operator[](const Variant &p_key) const;")
         result.append("\tVariant &operator[](const Variant &p_key);")
+        result.append(
+            "\tvoid set_typed(uint32_t p_key_type, const StringName &p_key_class_name, const Variant &p_key_script, uint32_t p_value_type, const StringName &p_value_class_name, const Variant &p_value_script);"
+        )
+        result.append("\tvoid _ref(const Dictionary &p_from) const;")
 
     result.append("};")
 
@@ -1126,6 +1132,32 @@ def generate_engine_classes_bindings(api, output_dir, use_template_get_node):
                                         fully_used_classes.add(array_type_name)
                                     else:
                                         used_classes.add(array_type_name)
+                            elif type_name.startswith("typeddictionary::"):
+                                fully_used_classes.add("TypedDictionary")
+                                dict_type_name = type_name.replace("typeddictionary::", "")
+                                if dict_type_name.startswith("const "):
+                                    dict_type_name = dict_type_name[6:]
+                                dict_type_names = dict_type_name.split(",")
+                                dict_type_name = dict_type_names[0]
+                                if dict_type_name.endswith("*"):
+                                    dict_type_name = dict_type_name[:-1]
+                                if is_included(dict_type_name, class_name):
+                                    if is_enum(dict_type_name):
+                                        fully_used_classes.add(get_enum_class(dict_type_name))
+                                    elif "default_value" in argument:
+                                        fully_used_classes.add(dict_type_name)
+                                    else:
+                                        used_classes.add(dict_type_name)
+                                dict_type_name = dict_type_names[2]
+                                if dict_type_name.endswith("*"):
+                                    dict_type_name = dict_type_name[:-1]
+                                if is_included(dict_type_name, class_name):
+                                    if is_enum(dict_type_name):
+                                        fully_used_classes.add(get_enum_class(dict_type_name))
+                                    elif "default_value" in argument:
+                                        fully_used_classes.add(dict_type_name)
+                                    else:
+                                        used_classes.add(dict_type_name)
                             elif is_enum(type_name):
                                 fully_used_classes.add(get_enum_class(type_name))
                             elif "default_value" in argument:
@@ -1155,6 +1187,32 @@ def generate_engine_classes_bindings(api, output_dir, use_template_get_node):
                                     fully_used_classes.add(array_type_name)
                                 else:
                                     used_classes.add(array_type_name)
+                        elif type_name.startswith("typeddictionary::"):
+                            fully_used_classes.add("TypedDictionary")
+                            dict_type_name = type_name.replace("typeddictionary::", "")
+                            if dict_type_name.startswith("const "):
+                                dict_type_name = dict_type_name[6:]
+                            dict_type_names = dict_type_name.split(",")
+                            dict_type_name = dict_type_names[0]
+                            if dict_type_name.endswith("*"):
+                                dict_type_name = dict_type_name[:-1]
+                            if is_included(dict_type_name, class_name):
+                                if is_enum(dict_type_name):
+                                    fully_used_classes.add(get_enum_class(dict_type_name))
+                                elif is_variant(dict_type_name):
+                                    fully_used_classes.add(dict_type_name)
+                                else:
+                                    used_classes.add(dict_type_name)
+                            dict_type_name = dict_type_names[2]
+                            if dict_type_name.endswith("*"):
+                                dict_type_name = dict_type_name[:-1]
+                            if is_included(dict_type_name, class_name):
+                                if is_enum(dict_type_name):
+                                    fully_used_classes.add(get_enum_class(dict_type_name))
+                                elif is_variant(dict_type_name):
+                                    fully_used_classes.add(dict_type_name)
+                                else:
+                                    used_classes.add(dict_type_name)
                         elif is_enum(type_name):
                             fully_used_classes.add(get_enum_class(type_name))
                         elif is_variant(type_name):
@@ -1281,6 +1339,8 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us
     for included in fully_used_classes:
         if included == "TypedArray":
             result.append("#include <godot_cpp/variant/typed_array.hpp>")
+        elif included == "TypedDictionary":
+            result.append("#include <godot_cpp/variant/typed_dictionary.hpp>")
         else:
             result.append(f"#include <godot_cpp/{get_include_path(included)}>")
 
@@ -2322,6 +2382,7 @@ def is_variant(type_name):
         or type_name in builtin_classes
         or type_name == "Nil"
         or type_name.startswith("typedarray::")
+        or type_name.startswith("typeddictionary::")
     )
 
 
@@ -2347,6 +2408,8 @@ def is_included(type_name, current_type):
     """
     if type_name.startswith("typedarray::"):
         return True
+    if type_name.startswith("typeddictionary::"):
+        return True
     to_include = get_enum_class(type_name) if is_enum(type_name) else type_name
     if to_include == current_type or is_pod_type(to_include):
         return False
@@ -2380,6 +2443,12 @@ def correct_typed_array(type_name):
     return type_name
 
 
+def correct_typed_dictionary(type_name):
+    if type_name.startswith("typeddictionary::"):
+        return type_name.replace("typeddictionary::", "TypedDictionary<").replace(",", ", ") + ">"
+    return type_name
+
+
 def correct_type(type_name, meta=None):
     type_conversion = {"float": "double", "int": "int64_t", "Nil": "Variant"}
     if meta != None:
@@ -2393,6 +2462,8 @@ def correct_type(type_name, meta=None):
         return type_conversion[type_name]
     if type_name.startswith("typedarray::"):
         return type_name.replace("typedarray::", "TypedArray<") + ">"
+    if type_name.startswith("typeddictionary::"):
+        return type_name.replace("typeddictionary::", "TypedDictionary<").replace(",", ", ") + ">"
     if is_enum(type_name):
         if is_bitfield(type_name):
             base_class = get_enum_class(type_name)
@@ -2497,6 +2568,8 @@ def get_default_value_for_type(type_name):
         return "false"
     if type_name.startswith("typedarray::"):
         return f"{correct_type(type_name)}()"
+    if type_name.startswith("typeddictionary::"):
+        return f"{correct_type(type_name)}()"
     if is_enum(type_name):
         return f"{correct_type(type_name)}(0)"
     if is_variant(type_name):

gdextension/gdextension_interface.h

@@ -2065,6 +2065,33 @@ typedef GDExtensionVariantPtr (*GDExtensionInterfaceDictionaryOperatorIndex)(GDE
  */
 typedef GDExtensionVariantPtr (*GDExtensionInterfaceDictionaryOperatorIndexConst)(GDExtensionConstTypePtr p_self, GDExtensionConstVariantPtr p_key);
 
+/**
+ * @name dictionary_ref
+ * @since 4.2
+ *
+ * Sets a Dictionary to be a reference to another Dictionary object.
+ *
+ * @param p_self A pointer to the Dictionary object to update.
+ * @param p_from A pointer to the Dictionary object to reference.
+ */
+typedef void (*GDExtensionInterfaceDictionaryRef)(GDExtensionTypePtr p_self, GDExtensionConstTypePtr p_from);
+
+/**
+ * @name dictionary_set_typed
+ * @since 4.2
+ *
+ * Makes a Dictionary into a typed Dictionary.
+ *
+ * @param p_self A pointer to the Dictionary.
+ * @param p_key_type The type of Variant the Dictionary key will store.
+ * @param p_key_class_name A pointer to a StringName with the name of the object (if p_key_type is GDEXTENSION_VARIANT_TYPE_OBJECT).
+ * @param p_key_script A pointer to a Script object (if p_key_type is GDEXTENSION_VARIANT_TYPE_OBJECT and the base class is extended by a script).
+ * @param p_value_type The type of Variant the Dictionary value will store.
+ * @param p_value_class_name A pointer to a StringName with the name of the object (if p_value_type is GDEXTENSION_VARIANT_TYPE_OBJECT).
+ * @param p_value_script A pointer to a Script object (if p_value_type is GDEXTENSION_VARIANT_TYPE_OBJECT and the base class is extended by a script).
+ */
+typedef void (*GDExtensionInterfaceDictionarySetTyped)(GDExtensionTypePtr p_self, GDExtensionVariantType p_key_type, GDExtensionConstStringNamePtr p_key_class_name, GDExtensionConstVariantPtr p_key_script, GDExtensionVariantType p_value_type, GDExtensionConstStringNamePtr p_value_class_name, GDExtensionConstVariantPtr p_value_script);
+
 /* INTERFACE: Object */
 
 /**