Identifiers containing double underscore are reserved according to the C++ standard

Rename __* to _gde_*

https://timsong-cpp.github.io/cppwp/n3337/global.names

https://en.cppreference.com/w/cpp/language/identifiers

Identifiers appearing as a token or preprocessing token (i.e., not in user-defined-string-literal like operator ""id) (since C++11) of one of the following forms are reserved:
 - identifiers with a double underscore anywhere;
 - identifiers that begin with an underscore followed by an uppercase letter;
 - in the global namespace, identifiers that begin with an underscore.

binding_generator.py

@@ -791,24 +791,24 @@ def generate_builtin_class_source(builtin_api, size, used_classes, fully_used_cl
         result.append("\tString::_init_bindings_constructors_destructor();")
     result.append(f"\t{class_name}::_init_bindings_constructors_destructor();")
 
-    result.append("\tStringName __name;")
+    result.append("\tStringName _gde_name;")
 
     if "methods" in builtin_api:
         for method in builtin_api["methods"]:
             # TODO: Add error check for hash mismatch.
-            result.append(f'\t__name = StringName("{method["name"]}");')
+            result.append(f'\t_gde_name = StringName("{method["name"]}");')
             result.append(
-                f'\t_method_bindings.method_{method["name"]} = internal::gdextension_interface_variant_get_ptr_builtin_method({enum_type_name}, __name._native_ptr(), {method["hash"]});'
+                f'\t_method_bindings.method_{method["name"]} = internal::gdextension_interface_variant_get_ptr_builtin_method({enum_type_name}, _gde_name._native_ptr(), {method["hash"]});'
             )
 
     if "members" in builtin_api:
         for member in builtin_api["members"]:
-            result.append(f'\t__name = StringName("{member["name"]}");')
+            result.append(f'\t_gde_name = StringName("{member["name"]}");')
             result.append(
-                f'\t_method_bindings.member_{member["name"]}_setter = internal::gdextension_interface_variant_get_ptr_setter({enum_type_name}, __name._native_ptr());'
+                f'\t_method_bindings.member_{member["name"]}_setter = internal::gdextension_interface_variant_get_ptr_setter({enum_type_name}, _gde_name._native_ptr());'
             )
             result.append(
-                f'\t_method_bindings.member_{member["name"]}_getter = internal::gdextension_interface_variant_get_ptr_getter({enum_type_name}, __name._native_ptr());'
+                f'\t_method_bindings.member_{member["name"]}_getter = internal::gdextension_interface_variant_get_ptr_getter({enum_type_name}, _gde_name._native_ptr());'
             )
 
     if "indexing_return_type" in builtin_api:
@@ -1443,15 +1443,15 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
 
     if is_singleton:
         result.append(f"{class_name} *{class_name}::get_singleton() {{")
-        result.append(f"\tconst StringName __class_name = {class_name}::get_class_static();")
+        result.append(f"\tconst StringName _gde_class_name = {class_name}::get_class_static();")
         result.append(
-            "\tstatic GDExtensionObjectPtr singleton_obj = internal::gdextension_interface_global_get_singleton(__class_name._native_ptr());"
+            "\tstatic GDExtensionObjectPtr singleton_obj = internal::gdextension_interface_global_get_singleton(_gde_class_name._native_ptr());"
         )
         result.append("#ifdef DEBUG_ENABLED")
         result.append("\tERR_FAIL_COND_V(singleton_obj == nullptr, nullptr);")
         result.append("#endif // DEBUG_ENABLED")
         result.append(
-            f"\tstatic {class_name} *singleton = reinterpret_cast<{class_name} *>(internal::gdextension_interface_object_get_instance_binding(singleton_obj, internal::token, &{class_name}::___binding_callbacks));"
+            f"\tstatic {class_name} *singleton = reinterpret_cast<{class_name} *>(internal::gdextension_interface_object_get_instance_binding(singleton_obj, internal::token, &{class_name}::_gde_binding_callbacks));"
         )
         result.append("\treturn singleton;")
         result.append("}")
@@ -1470,20 +1470,20 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
             result.append(method_signature + " {")
 
             # Method body.
-            result.append(f"\tconst StringName __class_name = {class_name}::get_class_static();")
-            result.append(f'\tconst StringName __method_name = "{method["name"]}";')
+            result.append(f"\tconst StringName _gde_class_name = {class_name}::get_class_static();")
+            result.append(f'\tconst StringName _gde_method_name = "{method["name"]}";')
             result.append(
-                f'\tstatic GDExtensionMethodBindPtr ___method_bind = internal::gdextension_interface_classdb_get_method_bind(__class_name._native_ptr(), __method_name._native_ptr(), {method["hash"]});'
+                f'\tstatic GDExtensionMethodBindPtr _gde_method_bind = internal::gdextension_interface_classdb_get_method_bind(_gde_class_name._native_ptr(), _gde_method_name._native_ptr(), {method["hash"]});'
             )
             method_call = "\t"
             has_return = "return_value" in method and method["return_value"]["type"] != "void"
 
             if has_return:
                 result.append(
-                    f'\tCHECK_METHOD_BIND_RET(___method_bind, {get_default_value_for_type(method["return_value"]["type"])});'
+                    f'\tCHECK_METHOD_BIND_RET(_gde_method_bind, {get_default_value_for_type(method["return_value"]["type"])});'
                 )
             else:
-                result.append("\tCHECK_METHOD_BIND(___method_bind);")
+                result.append("\tCHECK_METHOD_BIND(_gde_method_bind);")
 
             is_ref = False
             if not vararg:
@@ -1492,34 +1492,34 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
                     meta_type = method["return_value"]["meta"] if "meta" in method["return_value"] else None
                     if is_enum(return_type):
                         if method["is_static"]:
-                            method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret<int64_t>(___method_bind, nullptr"
+                            method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret<int64_t>(_gde_method_bind, nullptr"
                         else:
-                            method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret<int64_t>(___method_bind, _owner"
+                            method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret<int64_t>(_gde_method_bind, _owner"
                     elif is_pod_type(return_type) or is_variant(return_type):
                         if method["is_static"]:
-                            method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(___method_bind, nullptr"
+                            method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(_gde_method_bind, nullptr"
                         else:
-                            method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(___method_bind, _owner"
+                            method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(_gde_method_bind, _owner"
                     elif is_refcounted(return_type):
                         if method["is_static"]:
-                            method_call += f"return Ref<{return_type}>::___internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(___method_bind, nullptr"
+                            method_call += f"return Ref<{return_type}>::_gde_internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, nullptr"
                         else:
-                            method_call += f"return Ref<{return_type}>::___internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(___method_bind, _owner"
+                            method_call += f"return Ref<{return_type}>::_gde_internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, _owner"
                         is_ref = True
                     else:
                         if method["is_static"]:
                             method_call += (
-                                f"return internal::_call_native_mb_ret_obj<{return_type}>(___method_bind, nullptr"
+                                f"return internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, nullptr"
                             )
                         else:
                             method_call += (
-                                f"return internal::_call_native_mb_ret_obj<{return_type}>(___method_bind, _owner"
+                                f"return internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, _owner"
                             )
                 else:
                     if method["is_static"]:
-                        method_call += "internal::_call_native_mb_no_ret(___method_bind, nullptr"
+                        method_call += "internal::_call_native_mb_no_ret(_gde_method_bind, nullptr"
                     else:
-                        method_call += "internal::_call_native_mb_no_ret(___method_bind, _owner"
+                        method_call += "internal::_call_native_mb_no_ret(_gde_method_bind, _owner"
 
                 if "arguments" in method:
                     method_call += ", "
@@ -1536,7 +1536,7 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
             else:  # vararg.
                 result.append("\tGDExtensionCallError error;")
                 result.append("\tVariant ret;")
-                method_call += "internal::gdextension_interface_object_method_bind_call(___method_bind, _owner, reinterpret_cast<GDExtensionConstVariantPtr *>(args), arg_count, &ret, &error"
+                method_call += "internal::gdextension_interface_object_method_bind_call(_gde_method_bind, _owner, reinterpret_cast<GDExtensionConstVariantPtr *>(args), arg_count, &ret, &error"
 
             if is_ref:
                 method_call += ")"  # Close Ref<> constructor.
@@ -1763,28 +1763,28 @@ def generate_utility_functions(api, output_dir):
 
         # Function body.
 
-        source.append(f'\tconst StringName __function_name = "{function["name"]}";')
+        source.append(f'\tconst StringName _gde_function_name = "{function["name"]}";')
         source.append(
-            f'\tstatic GDExtensionPtrUtilityFunction ___function = internal::gdextension_interface_variant_get_ptr_utility_function(__function_name._native_ptr(), {function["hash"]});'
+            f'\tstatic GDExtensionPtrUtilityFunction _gde_function = internal::gdextension_interface_variant_get_ptr_utility_function(_gde_function_name._native_ptr(), {function["hash"]});'
         )
         has_return = "return_type" in function and function["return_type"] != "void"
         if has_return:
             source.append(
-                f'\tCHECK_METHOD_BIND_RET(___function, {get_default_value_for_type(function["return_type"])});'
+                f'\tCHECK_METHOD_BIND_RET(_gde_function, {get_default_value_for_type(function["return_type"])});'
             )
         else:
-            source.append("\tCHECK_METHOD_BIND(___function);")
+            source.append("\tCHECK_METHOD_BIND(_gde_function);")
 
         function_call = "\t"
         if not vararg:
             if has_return:
                 function_call += "return "
                 if function["return_type"] == "Object":
-                    function_call += "internal::_call_utility_ret_obj(___function"
+                    function_call += "internal::_call_utility_ret_obj(_gde_function"
                 else:
-                    function_call += f'internal::_call_utility_ret<{get_gdextension_type(correct_type(function["return_type"]))}>(___function'
+                    function_call += f'internal::_call_utility_ret<{get_gdextension_type(correct_type(function["return_type"]))}>(_gde_function'
             else:
-                function_call += "internal::_call_utility_no_ret(___function"
+                function_call += "internal::_call_utility_no_ret(_gde_function"
 
             if "arguments" in function:
                 function_call += ", "
@@ -1803,7 +1803,7 @@ def generate_utility_functions(api, output_dir):
                 source.append(f'\t{get_gdextension_type(correct_type(function["return_type"]))} ret;')
             else:
                 source.append("\tVariant ret;")
-            function_call += "___function(&ret, reinterpret_cast<GDExtensionConstVariantPtr *>(args), arg_count"
+            function_call += "_gde_function(&ret, reinterpret_cast<GDExtensionConstVariantPtr *>(args), arg_count"
 
         function_call += ");"
         source.append(function_call)

include/godot_cpp/classes/ref.hpp

@@ -219,7 +219,7 @@ public:
 
 	// Used exclusively in the bindings to recreate the Ref Godot encapsulates in return values,
 	// without adding to the refcount.
-	inline static Ref<T> ___internal_constructor(Object *obj) {
+	inline static Ref<T> _gde_internal_constructor(Object *obj) {
 		Ref<T> r;
 		r.reference = (T *)obj;
 		return r;

include/godot_cpp/classes/wrapped.hpp

@@ -109,7 +109,7 @@ protected:
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
 	virtual const GDExtensionInstanceBindingCallbacks *_get_bindings_callbacks() const override {                                                                                      \
-		return &___binding_callbacks;                                                                                                                                                  \
+		return &_gde_binding_callbacks;                                                                                                                                                \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
 	static void (*_get_bind_methods())() {                                                                                                                                             \
@@ -288,97 +288,97 @@ public:
 		}                                                                                                                                                                              \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
-	static void *___binding_create_callback(void *p_token, void *p_instance) {                                                                                                         \
+	static void *_gde_binding_create_callback(void *p_token, void *p_instance) {                                                                                                       \
 		return nullptr;                                                                                                                                                                \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
-	static void ___binding_free_callback(void *p_token, void *p_instance, void *p_binding) {                                                                                           \
+	static void _gde_binding_free_callback(void *p_token, void *p_instance, void *p_binding) {                                                                                         \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
-	static GDExtensionBool ___binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) {                                                               \
+	static GDExtensionBool _gde_binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) {                                                             \
 		return true;                                                                                                                                                                   \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
-	static constexpr GDExtensionInstanceBindingCallbacks ___binding_callbacks = {                                                                                                      \
-		___binding_create_callback,                                                                                                                                                    \
-		___binding_free_callback,                                                                                                                                                      \
-		___binding_reference_callback,                                                                                                                                                 \
+	static constexpr GDExtensionInstanceBindingCallbacks _gde_binding_callbacks = {                                                                                                    \
+		_gde_binding_create_callback,                                                                                                                                                  \
+		_gde_binding_free_callback,                                                                                                                                                    \
+		_gde_binding_reference_callback,                                                                                                                                               \
 	};
 
 // Don't use this for your classes, use GDCLASS() instead.
-#define GDEXTENSION_CLASS(m_class, m_inherits)                                                                           \
-private:                                                                                                                 \
-	void operator=(const m_class &p_rval) {}                                                                             \
-                                                                                                                         \
-protected:                                                                                                               \
-	virtual const GDExtensionInstanceBindingCallbacks *_get_bindings_callbacks() const override {                        \
-		return &___binding_callbacks;                                                                                    \
-	}                                                                                                                    \
-                                                                                                                         \
-	m_class(const char *p_godot_class) : m_inherits(p_godot_class) {}                                                    \
-	m_class(GodotObject *p_godot_object) : m_inherits(p_godot_object) {}                                                 \
-                                                                                                                         \
-	static void (*_get_bind_methods())() {                                                                               \
-		return nullptr;                                                                                                  \
-	}                                                                                                                    \
-                                                                                                                         \
-	static void (Wrapped::*_get_notification())(int) {                                                                   \
-		return nullptr;                                                                                                  \
-	}                                                                                                                    \
-                                                                                                                         \
-	static bool (Wrapped::*_get_set())(const ::godot::StringName &p_name, const Variant &p_property) {                   \
-		return nullptr;                                                                                                  \
-	}                                                                                                                    \
-                                                                                                                         \
-	static bool (Wrapped::*_get_get())(const ::godot::StringName &p_name, Variant &r_ret) const {                        \
-		return nullptr;                                                                                                  \
-	}                                                                                                                    \
-                                                                                                                         \
-	static void (Wrapped::*_get_get_property_list())(List<PropertyInfo> * p_list) const {                                \
-		return nullptr;                                                                                                  \
-	}                                                                                                                    \
-                                                                                                                         \
-	static bool (Wrapped::*_get_property_can_revert())(const ::godot::StringName &p_name) {                              \
-		return nullptr;                                                                                                  \
-	}                                                                                                                    \
-                                                                                                                         \
-	static bool (Wrapped::*_get_property_get_revert())(const ::godot::StringName &p_name, Variant &) {                   \
-		return nullptr;                                                                                                  \
-	}                                                                                                                    \
-                                                                                                                         \
-	static String (Wrapped::*_get_to_string())() {                                                                       \
-		return nullptr;                                                                                                  \
-	}                                                                                                                    \
-                                                                                                                         \
-public:                                                                                                                  \
-	static void initialize_class() {}                                                                                    \
-                                                                                                                         \
-	static ::godot::StringName &get_class_static() {                                                                     \
-		static ::godot::StringName string_name = ::godot::StringName(#m_class);                                          \
-		return string_name;                                                                                              \
-	}                                                                                                                    \
-                                                                                                                         \
-	static ::godot::StringName &get_parent_class_static() {                                                              \
-		return m_inherits::get_class_static();                                                                           \
-	}                                                                                                                    \
-                                                                                                                         \
-	static void *___binding_create_callback(void *p_token, void *p_instance) {                                           \
-		/* Do not call memnew here, we don't want the postinitializer to be called */                                    \
-		return new ("") m_class((GodotObject *)p_instance);                                                              \
-	}                                                                                                                    \
-	static void ___binding_free_callback(void *p_token, void *p_instance, void *p_binding) {                             \
-		/* Explicitly call the deconstructor to ensure proper lifecycle for non-trivial members */                       \
-		reinterpret_cast<m_class *>(p_binding)->~m_class();                                                              \
-		Memory::free_static(reinterpret_cast<m_class *>(p_binding));                                                     \
-	}                                                                                                                    \
-	static GDExtensionBool ___binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) { \
-		return true;                                                                                                     \
-	}                                                                                                                    \
-	static constexpr GDExtensionInstanceBindingCallbacks ___binding_callbacks = {                                        \
-		___binding_create_callback,                                                                                      \
-		___binding_free_callback,                                                                                        \
-		___binding_reference_callback,                                                                                   \
-	};                                                                                                                   \
+#define GDEXTENSION_CLASS(m_class, m_inherits)                                                                             \
+private:                                                                                                                   \
+	void operator=(const m_class &p_rval) {}                                                                               \
+                                                                                                                           \
+protected:                                                                                                                 \
+	virtual const GDExtensionInstanceBindingCallbacks *_get_bindings_callbacks() const override {                          \
+		return &_gde_binding_callbacks;                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	m_class(const char *p_godot_class) : m_inherits(p_godot_class) {}                                                      \
+	m_class(GodotObject *p_godot_object) : m_inherits(p_godot_object) {}                                                   \
+                                                                                                                           \
+	static void (*_get_bind_methods())() {                                                                                 \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static void (Wrapped::*_get_notification())(int) {                                                                     \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static bool (Wrapped::*_get_set())(const ::godot::StringName &p_name, const Variant &p_property) {                     \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static bool (Wrapped::*_get_get())(const ::godot::StringName &p_name, Variant &r_ret) const {                          \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static void (Wrapped::*_get_get_property_list())(List<PropertyInfo> * p_list) const {                                  \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static bool (Wrapped::*_get_property_can_revert())(const ::godot::StringName &p_name) {                                \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static bool (Wrapped::*_get_property_get_revert())(const ::godot::StringName &p_name, Variant &) {                     \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static String (Wrapped::*_get_to_string())() {                                                                         \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+public:                                                                                                                    \
+	static void initialize_class() {}                                                                                      \
+                                                                                                                           \
+	static ::godot::StringName &get_class_static() {                                                                       \
+		static ::godot::StringName string_name = ::godot::StringName(#m_class);                                            \
+		return string_name;                                                                                                \
+	}                                                                                                                      \
+                                                                                                                           \
+	static ::godot::StringName &get_parent_class_static() {                                                                \
+		return m_inherits::get_class_static();                                                                             \
+	}                                                                                                                      \
+                                                                                                                           \
+	static void *_gde_binding_create_callback(void *p_token, void *p_instance) {                                           \
+		/* Do not call memnew here, we don't want the post-initializer to be called */                                     \
+		return new ("") m_class((GodotObject *)p_instance);                                                                \
+	}                                                                                                                      \
+	static void _gde_binding_free_callback(void *p_token, void *p_instance, void *p_binding) {                             \
+		/* Explicitly call the deconstructor to ensure proper lifecycle for non-trivial members */                         \
+		reinterpret_cast<m_class *>(p_binding)->~m_class();                                                                \
+		Memory::free_static(reinterpret_cast<m_class *>(p_binding));                                                       \
+	}                                                                                                                      \
+	static GDExtensionBool _gde_binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) { \
+		return true;                                                                                                       \
+	}                                                                                                                      \
+	static constexpr GDExtensionInstanceBindingCallbacks _gde_binding_callbacks = {                                        \
+		_gde_binding_create_callback,                                                                                      \
+		_gde_binding_free_callback,                                                                                        \
+		_gde_binding_reference_callback,                                                                                   \
+	};                                                                                                                     \
 	m_class() : m_class(#m_class) {}
 
 #endif // GODOT_WRAPPED_HPP

include/godot_cpp/core/class_db.hpp

@@ -150,22 +150,22 @@ public:
 	godot::ClassDB::bind_integer_constant(get_class_static(), "", #m_constant, m_constant);
 
 #define BIND_ENUM_CONSTANT(m_constant) \
-	godot::ClassDB::bind_integer_constant(get_class_static(), godot::__constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant);
+	godot::ClassDB::bind_integer_constant(get_class_static(), godot::_gde_constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant);
 
 #define BIND_BITFIELD_FLAG(m_constant) \
-	godot::ClassDB::bind_integer_constant(get_class_static(), godot::__constant_get_bitfield_name(m_constant, #m_constant), #m_constant, m_constant, true);
-
-#define BIND_VIRTUAL_METHOD(m_class, m_method)                                                                                                  \
-	{                                                                                                                                           \
-		auto ___call##m_method = [](GDExtensionObjectPtr p_instance, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr p_ret) -> void { \
-			call_with_ptr_args(reinterpret_cast<m_class *>(p_instance), &m_class::m_method, p_args, p_ret);                                     \
-		};                                                                                                                                      \
-		godot::ClassDB::bind_virtual_method(m_class::get_class_static(), #m_method, ___call##m_method);                                         \
+	godot::ClassDB::bind_integer_constant(get_class_static(), godot::_gde_constant_get_bitfield_name(m_constant, #m_constant), #m_constant, m_constant, true);
+
+#define BIND_VIRTUAL_METHOD(m_class, m_method)                                                                                                \
+	{                                                                                                                                         \
+		auto _call##m_method = [](GDExtensionObjectPtr p_instance, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr p_ret) -> void { \
+			call_with_ptr_args(reinterpret_cast<m_class *>(p_instance), &m_class::m_method, p_args, p_ret);                                   \
+		};                                                                                                                                    \
+		godot::ClassDB::bind_virtual_method(m_class::get_class_static(), #m_method, _call##m_method);                                         \
 	}
 
 template <class T, bool is_abstract>
 void ClassDB::_register_class(bool p_virtual) {
-	instance_binding_callbacks[T::get_class_static()] = &T::___binding_callbacks;
+	instance_binding_callbacks[T::get_class_static()] = &T::_gde_binding_callbacks;
 
 	// Register this class within our plugin
 	ClassInfo cl;
@@ -221,7 +221,7 @@ void ClassDB::register_abstract_class() {
 
 template <class T>
 void ClassDB::register_engine_class() {
-	instance_binding_callbacks[T::get_class_static()] = &T::___binding_callbacks;
+	instance_binding_callbacks[T::get_class_static()] = &T::_gde_binding_callbacks;
 }
 
 template <class N, class M, typename... VarArgs>

include/godot_cpp/core/method_bind.hpp

@@ -268,8 +268,8 @@ MethodBind *create_vararg_method_bind(R (T::*p_method)(const Variant **, GDExten
 }
 
 #ifndef TYPED_METHOD_BIND
-class ___UnexistingClass;
-#define MB_T ___UnexistingClass
+class _gde_UnexistingClass;
+#define MB_T _gde_UnexistingClass
 #else
 #define MB_T T
 #endif

include/godot_cpp/core/type_info.hpp

@@ -241,7 +241,7 @@ inline String enum_qualified_name_to_class_info_name(const String &p_qualified_n
 	TEMPL_MAKE_ENUM_TYPE_INFO(m_enum, const m_enum &)
 
 template <typename T>
-inline StringName __constant_get_enum_name(T param, StringName p_constant) {
+inline StringName _gde_constant_get_enum_name(T param, StringName p_constant) {
 	if (GetTypeInfo<T>::VARIANT_TYPE == Variant::NIL) {
 		ERR_PRINT(("Missing VARIANT_ENUM_CAST for constant's enum: " + String(p_constant)).utf8().get_data());
 	}
@@ -288,7 +288,7 @@ public:
 	TEMPL_MAKE_BITFIELD_TYPE_INFO(m_enum, const m_enum &)
 
 template <typename T>
-inline StringName __constant_get_bitfield_name(T param, StringName p_constant) {
+inline StringName _gde_constant_get_bitfield_name(T param, StringName p_constant) {
 	if (GetTypeInfo<T>::VARIANT_TYPE == Variant::NIL) {
 		ERR_PRINT(("Missing VARIANT_ENUM_CAST for constant's bitfield: " + String(p_constant)).utf8().get_data());
 	}

src/core/object.cpp

@@ -54,7 +54,7 @@ Object *get_object_instance_binding(GodotObject *p_engine_object) {
 		binding_callbacks = ClassDB::get_instance_binding_callbacks(class_name);
 	}
 	if (binding_callbacks == nullptr) {
-		binding_callbacks = &Object::___binding_callbacks;
+		binding_callbacks = &Object::_gde_binding_callbacks;
 	}
 
 	return reinterpret_cast<Object *>(gdextension_interface_object_get_instance_binding(p_engine_object, token, binding_callbacks));