C#: Generate the correct integer and floating point types

core/make_binders.py

@@ -9,6 +9,12 @@ public:
 	$ifret R$ $ifnoret void$ (T::*method)($arg, P@$) $ifconst const$;
 #ifdef DEBUG_METHODS_ENABLED
 	virtual Variant::Type _gen_argument_type(int p_arg) const { return _get_argument_type(p_arg); }
+	virtual GodotTypeInfo::Metadata get_argument_meta(int p_arg) const {
+		$ifret if (p_arg==-1) return GetTypeInfo<R>::METADATA;$
+		$arg if (p_arg==(@-1)) return GetTypeInfo<P@>::METADATA;
+		$
+		return GodotTypeInfo::METADATA_NONE;
+	}
 	Variant::Type _get_argument_type(int p_argument) const {
 		$ifret if (p_argument==-1) return (Variant::Type)GetTypeInfo<R>::VARIANT_TYPE;$
 		$arg if (p_argument==(@-1)) return (Variant::Type)GetTypeInfo<P@>::VARIANT_TYPE;
@@ -94,6 +100,12 @@ public:
 
 #ifdef DEBUG_METHODS_ENABLED
 	virtual Variant::Type _gen_argument_type(int p_arg) const { return _get_argument_type(p_arg); }
+	virtual GodotTypeInfo::Metadata get_argument_meta(int p_arg) const {
+		$ifret if (p_arg==-1) return GetTypeInfo<R>::METADATA;$
+		$arg if (p_arg==(@-1)) return GetTypeInfo<P@>::METADATA;
+		$
+		return GodotTypeInfo::METADATA_NONE;
+	}
 
 	Variant::Type _get_argument_type(int p_argument) const {
 		$ifret if (p_argument==-1) return (Variant::Type)GetTypeInfo<R>::VARIANT_TYPE;$

core/method_bind.h

@@ -273,6 +273,8 @@ public:
 	void set_argument_names(const Vector<StringName> &p_names); //set by class, db, can't be inferred otherwise
 	Vector<StringName> get_argument_names() const;
 
+	virtual GodotTypeInfo::Metadata get_argument_meta(int p_arg) const = 0;
+
 #endif
 	void set_hint_flags(uint32_t p_hint) { hint_flags = p_hint; }
 	uint32_t get_hint_flags() const { return hint_flags | (is_const() ? METHOD_FLAG_CONST : 0) | (is_vararg() ? METHOD_FLAG_VARARG : 0); }
@@ -329,6 +331,10 @@ public:
 		return _gen_argument_type_info(p_arg).type;
 	}
 
+	virtual GodotTypeInfo::Metadata get_argument_meta(int) const {
+		return GodotTypeInfo::METADATA_NONE;
+	}
+
 #else
 
 	virtual Variant::Type _gen_argument_type(int p_arg) const {

core/reference.h

@@ -375,7 +375,8 @@ struct PtrToArg<const RefPtr &> {
 
 template <class T>
 struct GetTypeInfo<Ref<T> > {
-	enum { VARIANT_TYPE = Variant::OBJECT };
+	static const Variant::Type VARIANT_TYPE = Variant::OBJECT;
+	static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;
 
 	static inline PropertyInfo get_class_info() {
 		return PropertyInfo(Variant::OBJECT, String(), PROPERTY_HINT_RESOURCE_TYPE, T::get_class_static());
@@ -384,7 +385,8 @@ struct GetTypeInfo<Ref<T> > {
 
 template <class T>
 struct GetTypeInfo<const Ref<T> &> {
-	enum { VARIANT_TYPE = Variant::OBJECT };
+	static const Variant::Type VARIANT_TYPE = Variant::OBJECT;
+	static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;
 
 	static inline PropertyInfo get_class_info() {
 		return PropertyInfo(Variant::OBJECT, String(), PROPERTY_HINT_RESOURCE_TYPE, T::get_class_static());

core/type_info.h

@@ -67,43 +67,80 @@ struct TypeInherits {
 							  !TypesAreSame<B volatile const, void volatile const>::value;
 };
 
+namespace GodotTypeInfo {
+enum Metadata {
+	METADATA_NONE,
+	METADATA_INT_IS_INT8,
+	METADATA_INT_IS_INT16,
+	METADATA_INT_IS_INT32,
+	METADATA_INT_IS_INT64,
+	METADATA_INT_IS_UINT8,
+	METADATA_INT_IS_UINT16,
+	METADATA_INT_IS_UINT32,
+	METADATA_INT_IS_UINT64,
+	METADATA_REAL_IS_FLOAT,
+	METADATA_REAL_IS_DOUBLE
+};
+}
+
 template <class T, typename = void>
 struct GetTypeInfo {
 	static const Variant::Type VARIANT_TYPE = Variant::NIL;
+	static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;
 	static inline PropertyInfo get_class_info() {
 		ERR_PRINT("GetTypeInfo fallback. Bug!");
 		return PropertyInfo(); // Not "Nil", this is an error
 	}
 };
 
-#define MAKE_TYPE_INFO(m_type, m_var_type)                    \
-	template <>                                               \
-	struct GetTypeInfo<m_type> {                              \
-		static const Variant::Type VARIANT_TYPE = m_var_type; \
-		static inline PropertyInfo get_class_info() {         \
-			return PropertyInfo(VARIANT_TYPE, String());      \
-		}                                                     \
-	};                                                        \
-	template <>                                               \
-	struct GetTypeInfo<const m_type &> {                      \
-		static const Variant::Type VARIANT_TYPE = m_var_type; \
-		static inline PropertyInfo get_class_info() {         \
-			return PropertyInfo(VARIANT_TYPE, String());      \
-		}                                                     \
+#define MAKE_TYPE_INFO(m_type, m_var_type)                                            \
+	template <>                                                                       \
+	struct GetTypeInfo<m_type> {                                                      \
+		static const Variant::Type VARIANT_TYPE = m_var_type;                         \
+		static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE; \
+		static inline PropertyInfo get_class_info() {                                 \
+			return PropertyInfo(VARIANT_TYPE, String());                              \
+		}                                                                             \
+	};                                                                                \
+	template <>                                                                       \
+	struct GetTypeInfo<const m_type &> {                                              \
+		static const Variant::Type VARIANT_TYPE = m_var_type;                         \
+		static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE; \
+		static inline PropertyInfo get_class_info() {                                 \
+			return PropertyInfo(VARIANT_TYPE, String());                              \
+		}                                                                             \
+	};
+
+#define MAKE_TYPE_INFO_WITH_META(m_type, m_var_type, m_metadata)    \
+	template <>                                                     \
+	struct GetTypeInfo<m_type> {                                    \
+		static const Variant::Type VARIANT_TYPE = m_var_type;       \
+		static const GodotTypeInfo::Metadata METADATA = m_metadata; \
+		static inline PropertyInfo get_class_info() {               \
+			return PropertyInfo(VARIANT_TYPE, String());            \
+		}                                                           \
+	};                                                              \
+	template <>                                                     \
+	struct GetTypeInfo<const m_type &> {                            \
+		static const Variant::Type VARIANT_TYPE = m_var_type;       \
+		static const GodotTypeInfo::Metadata METADATA = m_metadata; \
+		static inline PropertyInfo get_class_info() {               \
+			return PropertyInfo(VARIANT_TYPE, String());            \
+		}                                                           \
 	};
 
 MAKE_TYPE_INFO(bool, Variant::BOOL)
-MAKE_TYPE_INFO(uint8_t, Variant::INT)
-MAKE_TYPE_INFO(int8_t, Variant::INT)
-MAKE_TYPE_INFO(uint16_t, Variant::INT)
-MAKE_TYPE_INFO(int16_t, Variant::INT)
-MAKE_TYPE_INFO(uint32_t, Variant::INT)
-MAKE_TYPE_INFO(int32_t, Variant::INT)
-MAKE_TYPE_INFO(int64_t, Variant::INT)
-MAKE_TYPE_INFO(uint64_t, Variant::INT)
+MAKE_TYPE_INFO_WITH_META(uint8_t, Variant::INT, GodotTypeInfo::METADATA_INT_IS_UINT8)
+MAKE_TYPE_INFO_WITH_META(int8_t, Variant::INT, GodotTypeInfo::METADATA_INT_IS_INT8)
+MAKE_TYPE_INFO_WITH_META(uint16_t, Variant::INT, GodotTypeInfo::METADATA_INT_IS_UINT16)
+MAKE_TYPE_INFO_WITH_META(int16_t, Variant::INT, GodotTypeInfo::METADATA_INT_IS_INT16)
+MAKE_TYPE_INFO_WITH_META(uint32_t, Variant::INT, GodotTypeInfo::METADATA_INT_IS_UINT32)
+MAKE_TYPE_INFO_WITH_META(int32_t, Variant::INT, GodotTypeInfo::METADATA_INT_IS_INT32)
+MAKE_TYPE_INFO_WITH_META(uint64_t, Variant::INT, GodotTypeInfo::METADATA_INT_IS_UINT64)
+MAKE_TYPE_INFO_WITH_META(int64_t, Variant::INT, GodotTypeInfo::METADATA_INT_IS_INT64)
 MAKE_TYPE_INFO(wchar_t, Variant::INT)
-MAKE_TYPE_INFO(float, Variant::REAL)
-MAKE_TYPE_INFO(double, Variant::REAL)
+MAKE_TYPE_INFO_WITH_META(float, Variant::REAL, GodotTypeInfo::METADATA_REAL_IS_FLOAT)
+MAKE_TYPE_INFO_WITH_META(double, Variant::REAL, GodotTypeInfo::METADATA_REAL_IS_DOUBLE)
 
 MAKE_TYPE_INFO(String, Variant::STRING)
 MAKE_TYPE_INFO(Vector2, Variant::VECTOR2)
@@ -138,6 +175,7 @@ MAKE_TYPE_INFO(BSP_Tree, Variant::DICTIONARY)
 template <>
 struct GetTypeInfo<RefPtr> {
 	static const Variant::Type VARIANT_TYPE = Variant::OBJECT;
+	static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;
 	static inline PropertyInfo get_class_info() {
 		return PropertyInfo(Variant::OBJECT, String(), PROPERTY_HINT_RESOURCE_TYPE, "Reference");
 	}
@@ -145,6 +183,7 @@ struct GetTypeInfo<RefPtr> {
 template <>
 struct GetTypeInfo<const RefPtr &> {
 	static const Variant::Type VARIANT_TYPE = Variant::OBJECT;
+	static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;
 	static inline PropertyInfo get_class_info() {
 		return PropertyInfo(Variant::OBJECT, String(), PROPERTY_HINT_RESOURCE_TYPE, "Reference");
 	}
@@ -154,6 +193,7 @@ struct GetTypeInfo<const RefPtr &> {
 template <>
 struct GetTypeInfo<Variant> {
 	static const Variant::Type VARIANT_TYPE = Variant::NIL;
+	static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;
 	static inline PropertyInfo get_class_info() {
 		return PropertyInfo(Variant::NIL, String(), PROPERTY_HINT_NONE, String(), PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_NIL_IS_VARIANT);
 	}
@@ -162,25 +202,28 @@ struct GetTypeInfo<Variant> {
 template <>
 struct GetTypeInfo<const Variant &> {
 	static const Variant::Type VARIANT_TYPE = Variant::NIL;
+	static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;
 	static inline PropertyInfo get_class_info() {
 		return PropertyInfo(Variant::NIL, String(), PROPERTY_HINT_NONE, String(), PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_NIL_IS_VARIANT);
 	}
 };
 
-#define MAKE_TEMPLATE_TYPE_INFO(m_template, m_type, m_var_type) \
-	template <>                                                 \
-	struct GetTypeInfo<m_template<m_type> > {                   \
-		static const Variant::Type VARIANT_TYPE = m_var_type;   \
-		static inline PropertyInfo get_class_info() {           \
-			return PropertyInfo(VARIANT_TYPE, String());        \
-		}                                                       \
-	};                                                          \
-	template <>                                                 \
-	struct GetTypeInfo<const m_template<m_type> &> {            \
-		static const Variant::Type VARIANT_TYPE = m_var_type;   \
-		static inline PropertyInfo get_class_info() {           \
-			return PropertyInfo(VARIANT_TYPE, String());        \
-		}                                                       \
+#define MAKE_TEMPLATE_TYPE_INFO(m_template, m_type, m_var_type)                       \
+	template <>                                                                       \
+	struct GetTypeInfo<m_template<m_type> > {                                         \
+		static const Variant::Type VARIANT_TYPE = m_var_type;                         \
+		static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE; \
+		static inline PropertyInfo get_class_info() {                                 \
+			return PropertyInfo(VARIANT_TYPE, String());                              \
+		}                                                                             \
+	};                                                                                \
+	template <>                                                                       \
+	struct GetTypeInfo<const m_template<m_type> &> {                                  \
+		static const Variant::Type VARIANT_TYPE = m_var_type;                         \
+		static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE; \
+		static inline PropertyInfo get_class_info() {                                 \
+			return PropertyInfo(VARIANT_TYPE, String());                              \
+		}                                                                             \
 	};
 
 MAKE_TEMPLATE_TYPE_INFO(Vector, uint8_t, Variant::POOL_BYTE_ARRAY)
@@ -202,6 +245,7 @@ MAKE_TEMPLATE_TYPE_INFO(PoolVector, Face3, Variant::POOL_VECTOR3_ARRAY)
 template <typename T>
 struct GetTypeInfo<T *, typename EnableIf<TypeInherits<Object, T>::value>::type> {
 	static const Variant::Type VARIANT_TYPE = Variant::OBJECT;
+	static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;
 	static inline PropertyInfo get_class_info() {
 		return PropertyInfo(StringName(T::get_class_static()));
 	}
@@ -210,6 +254,7 @@ struct GetTypeInfo<T *, typename EnableIf<TypeInherits<Object, T>::value>::type>
 template <typename T>
 struct GetTypeInfo<const T *, typename EnableIf<TypeInherits<Object, T>::value>::type> {
 	static const Variant::Type VARIANT_TYPE = Variant::OBJECT;
+	static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;
 	static inline PropertyInfo get_class_info() {
 		return PropertyInfo(StringName(T::get_class_static()));
 	}
@@ -219,6 +264,7 @@ struct GetTypeInfo<const T *, typename EnableIf<TypeInherits<Object, T>::value>:
 	template <>                                                                                                                                                                   \
 	struct GetTypeInfo<m_impl> {                                                                                                                                                  \
 		static const Variant::Type VARIANT_TYPE = Variant::INT;                                                                                                                   \
+		static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;                                                                                             \
 		static inline PropertyInfo get_class_info() {                                                                                                                             \
 			return PropertyInfo(Variant::INT, String(), PROPERTY_HINT_NONE, String(), PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_CLASS_IS_ENUM, String(#m_enum).replace("::", ".")); \
 		}                                                                                                                                                                         \

modules/mono/editor/bindings_generator.cpp

@@ -2125,6 +2125,58 @@ const BindingsGenerator::TypeInterface *BindingsGenerator::_get_type_or_placehol
 	return &placeholder_types.insert(placeholder.cname, placeholder)->get();
 }
 
+StringName BindingsGenerator::_get_int_type_name_from_meta(GodotTypeInfo::Metadata p_meta) {
+
+	switch (p_meta) {
+		case GodotTypeInfo::METADATA_INT_IS_INT8:
+			return "sbyte";
+			break;
+		case GodotTypeInfo::METADATA_INT_IS_INT16:
+			return "short";
+			break;
+		case GodotTypeInfo::METADATA_INT_IS_INT32:
+			return "int";
+			break;
+		case GodotTypeInfo::METADATA_INT_IS_INT64:
+			return "long";
+			break;
+		case GodotTypeInfo::METADATA_INT_IS_UINT8:
+			return "byte";
+			break;
+		case GodotTypeInfo::METADATA_INT_IS_UINT16:
+			return "ushort";
+			break;
+		case GodotTypeInfo::METADATA_INT_IS_UINT32:
+			return "uint";
+			break;
+		case GodotTypeInfo::METADATA_INT_IS_UINT64:
+			return "ulong";
+			break;
+		default:
+			// Assume INT32
+			return "int";
+	}
+}
+
+StringName BindingsGenerator::_get_float_type_name_from_meta(GodotTypeInfo::Metadata p_meta) {
+
+	switch (p_meta) {
+		case GodotTypeInfo::METADATA_REAL_IS_FLOAT:
+			return "float";
+			break;
+		case GodotTypeInfo::METADATA_REAL_IS_DOUBLE:
+			return "double";
+			break;
+		default:
+			// Assume real_t (float or double depending of REAL_T_IS_DOUBLE)
+#ifdef REAL_T_IS_DOUBLE
+			return "double";
+#else
+			return "float";
+#endif
+	}
+}
+
 void BindingsGenerator::_populate_object_type_interfaces() {
 
 	obj_types.clear();
@@ -2297,7 +2349,13 @@ void BindingsGenerator::_populate_object_type_interfaces() {
 			} else if (return_info.type == Variant::NIL) {
 				imethod.return_type.cname = name_cache.type_void;
 			} else {
-				imethod.return_type.cname = Variant::get_type_name(return_info.type);
+				if (return_info.type == Variant::INT) {
+					imethod.return_type.cname = _get_int_type_name_from_meta(m ? m->get_argument_meta(-1) : GodotTypeInfo::METADATA_NONE);
+				} else if (return_info.type == Variant::REAL) {
+					imethod.return_type.cname = _get_float_type_name_from_meta(m ? m->get_argument_meta(-1) : GodotTypeInfo::METADATA_NONE);
+				} else {
+					imethod.return_type.cname = Variant::get_type_name(return_info.type);
+				}
 			}
 
 			for (int i = 0; i < argc; i++) {
@@ -2316,7 +2374,13 @@ void BindingsGenerator::_populate_object_type_interfaces() {
 				} else if (arginfo.type == Variant::NIL) {
 					iarg.type.cname = name_cache.type_Variant;
 				} else {
-					iarg.type.cname = Variant::get_type_name(arginfo.type);
+					if (arginfo.type == Variant::INT) {
+						iarg.type.cname = _get_int_type_name_from_meta(m ? m->get_argument_meta(i) : GodotTypeInfo::METADATA_NONE);
+					} else if (arginfo.type == Variant::REAL) {
+						iarg.type.cname = _get_float_type_name_from_meta(m ? m->get_argument_meta(i) : GodotTypeInfo::METADATA_NONE);
+					} else {
+						iarg.type.cname = Variant::get_type_name(arginfo.type);
+					}
 				}
 
 				iarg.name = escape_csharp_keyword(snake_to_camel_case(iarg.name));
@@ -2582,7 +2646,6 @@ void BindingsGenerator::_populate_builtin_type_interfaces() {
 
 	// bool
 	itype = TypeInterface::create_value_type(String("bool"));
-
 	{
 		// MonoBoolean <---> bool
 		itype.c_in = "\t%0 %1_in = (%0)%1;\n";
@@ -2596,45 +2659,73 @@ void BindingsGenerator::_populate_builtin_type_interfaces() {
 	itype.im_type_out = itype.name;
 	builtin_types.insert(itype.cname, itype);
 
-	// int
-	// C interface is the same as that of enums. Remember to apply any
-	// changes done here to TypeInterface::postsetup_enum_type as well
-	itype = TypeInterface::create_value_type(String("int"));
-	itype.c_arg_in = "&%s_in";
+	// Integer types
 	{
-		// The expected types for parameters and return value in ptrcall are 'int64_t' or 'uint64_t'.
-		itype.c_in = "\t%0 %1_in = (%0)%1;\n";
-		itype.c_out = "\treturn (%0)%1;\n";
-		itype.c_type = "int64_t";
+		// C interface for 'uint32_t' is the same as that of enums. Remember to apply
+		// any of the changes done here to 'TypeInterface::postsetup_enum_type' as well.
+#define INSERT_INT_TYPE(m_name, m_c_type_in_out, m_c_type)        \
+	{                                                             \
+		itype = TypeInterface::create_value_type(String(m_name)); \
+		{                                                         \
+			itype.c_in = "\t%0 %1_in = (%0)%1;\n";                \
+			itype.c_out = "\treturn (%0)%1;\n";                   \
+			itype.c_type = #m_c_type;                             \
+			itype.c_arg_in = "&%s_in";                            \
+		}                                                         \
+		itype.c_type_in = #m_c_type_in_out;                       \
+		itype.c_type_out = itype.c_type_in;                       \
+		itype.im_type_in = itype.name;                            \
+		itype.im_type_out = itype.name;                           \
+		builtin_types.insert(itype.cname, itype);                 \
 	}
-	itype.c_type_in = "int32_t";
-	itype.c_type_out = itype.c_type_in;
-	itype.im_type_in = itype.name;
-	itype.im_type_out = itype.name;
-	builtin_types.insert(itype.cname, itype);
 
-	// real_t
-	itype = TypeInterface();
-	itype.name = "float"; // The name is always "float" in Variant, even with REAL_T_IS_DOUBLE.
-	itype.cname = itype.name;
-#ifdef REAL_T_IS_DOUBLE
-	itype.proxy_name = "double";
-#else
-	itype.proxy_name = "float";
-#endif
+		// The expected type for all integers in ptrcall is 'int64_t', so that's what we use for 'c_type'
+
+		INSERT_INT_TYPE("sbyte", int8_t, int64_t);
+		INSERT_INT_TYPE("short", int16_t, int64_t);
+		INSERT_INT_TYPE("int", int32_t, int64_t);
+		INSERT_INT_TYPE("long", int64_t, int64_t);
+		INSERT_INT_TYPE("byte", uint8_t, int64_t);
+		INSERT_INT_TYPE("ushort", uint16_t, int64_t);
+		INSERT_INT_TYPE("uint", uint32_t, int64_t);
+		INSERT_INT_TYPE("ulong", uint64_t, int64_t);
+	}
+
+	// Floating point types
 	{
-		// The expected type for parameters and return value in ptrcall is 'double'.
-		itype.c_in = "\t%0 %1_in = (%0)%1;\n";
-		itype.c_out = "\treturn (%0)%1;\n";
+		// float
+		itype = TypeInterface();
+		itype.name = "float";
+		itype.cname = itype.name;
+		itype.proxy_name = "float";
+		{
+			// The expected type for 'float' in ptrcall is 'double'
+			itype.c_in = "\t%0 %1_in = (%0)%1;\n";
+			itype.c_out = "\treturn (%0)%1;\n";
+			itype.c_type = "double";
+			itype.c_type_in = "float";
+			itype.c_type_out = "float";
+			itype.c_arg_in = "&%s_in";
+		}
+		itype.cs_type = itype.proxy_name;
+		itype.im_type_in = itype.proxy_name;
+		itype.im_type_out = itype.proxy_name;
+		builtin_types.insert(itype.cname, itype);
+
+		// double
+		itype = TypeInterface();
+		itype.name = "double";
+		itype.cname = itype.name;
+		itype.proxy_name = "double";
 		itype.c_type = "double";
-		itype.c_type_in = "real_t";
-		itype.c_type_out = "real_t";
-		itype.c_arg_in = "&%s_in";
+		itype.c_type_in = "double";
+		itype.c_type_out = "double";
+		itype.c_arg_in = "&%s";
+		itype.cs_type = itype.proxy_name;
+		itype.im_type_in = itype.proxy_name;
+		itype.im_type_out = itype.proxy_name;
+		builtin_types.insert(itype.cname, itype);
 	}
-	itype.cs_type = itype.proxy_name;
-	itype.im_type_in = itype.proxy_name;
-	itype.im_type_out = itype.proxy_name;
-	builtin_types.insert(itype.cname, itype);
 
 	// String
 	itype = TypeInterface();

modules/mono/editor/bindings_generator.h

@@ -403,8 +403,8 @@ class BindingsGenerator {
 		}
 
 		static void postsetup_enum_type(TypeInterface &r_enum_itype) {
-			// C interface is the same as that of 'int'. Remember to apply any
-			// changes done here to the 'int' type interface as well
+			// C interface for enums is the same as that of 'uint32_t'. Remember to apply
+			// any of the changes done here to the 'uint32_t' type interface as well.
 
 			r_enum_itype.c_arg_in = "&%s_in";
 			{
@@ -493,7 +493,6 @@ class BindingsGenerator {
 
 	struct NameCache {
 		StringName type_void;
-		StringName type_int;
 		StringName type_Array;
 		StringName type_Dictionary;
 		StringName type_Variant;
@@ -504,9 +503,19 @@ class BindingsGenerator {
 		StringName type_at_GlobalScope;
 		StringName enum_Error;
 
+		StringName type_sbyte;
+		StringName type_short;
+		StringName type_int;
+		StringName type_long;
+		StringName type_byte;
+		StringName type_ushort;
+		StringName type_uint;
+		StringName type_ulong;
+		StringName type_float;
+		StringName type_double;
+
 		NameCache() {
 			type_void = StaticCString::create("void");
-			type_int = StaticCString::create("int");
 			type_Array = StaticCString::create("Array");
 			type_Dictionary = StaticCString::create("Dictionary");
 			type_Variant = StaticCString::create("Variant");
@@ -516,6 +525,17 @@ class BindingsGenerator {
 			type_String = StaticCString::create("String");
 			type_at_GlobalScope = StaticCString::create("@GlobalScope");
 			enum_Error = StaticCString::create("Error");
+
+			type_sbyte = StaticCString::create("sbyte");
+			type_short = StaticCString::create("short");
+			type_int = StaticCString::create("int");
+			type_long = StaticCString::create("long");
+			type_byte = StaticCString::create("byte");
+			type_ushort = StaticCString::create("ushort");
+			type_uint = StaticCString::create("uint");
+			type_ulong = StaticCString::create("ulong");
+			type_float = StaticCString::create("float");
+			type_double = StaticCString::create("double");
 		}
 
 	private:
@@ -564,6 +584,9 @@ class BindingsGenerator {
 	const TypeInterface *_get_type_or_null(const TypeReference &p_typeref);
 	const TypeInterface *_get_type_or_placeholder(const TypeReference &p_typeref);
 
+	StringName _get_int_type_name_from_meta(GodotTypeInfo::Metadata p_meta);
+	StringName _get_float_type_name_from_meta(GodotTypeInfo::Metadata p_meta);
+
 	void _default_argument_from_variant(const Variant &p_val, ArgumentInterface &r_iarg);
 
 	void _populate_object_type_interfaces();

modules/mono/glue/Managed/Files/GD.cs

@@ -111,7 +111,7 @@ namespace Godot
             godot_icall_GD_printt(Array.ConvertAll(what, x => x.ToString()));
         }
 
-        public static double Randf()
+        public static float Randf()
         {
             return godot_icall_GD_randf();
         }
@@ -224,7 +224,7 @@ namespace Godot
         internal extern static void godot_icall_GD_printt(object[] what);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern static double godot_icall_GD_randf();
+        internal extern static float godot_icall_GD_randf();
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal extern static uint godot_icall_GD_randi();
@@ -232,6 +232,7 @@ namespace Godot
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal extern static void godot_icall_GD_randomize();
 
+
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal extern static double godot_icall_GD_rand_range(double from, double to);
 

modules/mono/glue/gd_glue.cpp

@@ -115,7 +115,7 @@ void godot_icall_GD_printt(MonoArray *p_what) {
 	print_line(str);
 }
 
-double godot_icall_GD_randf() {
+float godot_icall_GD_randf() {
 	return Math::randf();
 }
 

modules/mono/glue/gd_glue.h

@@ -53,7 +53,7 @@ void godot_icall_GD_prints(MonoArray *p_what);
 
 void godot_icall_GD_printt(MonoArray *p_what);
 
-double godot_icall_GD_randf();
+float godot_icall_GD_randf();
 
 uint32_t godot_icall_GD_randi();