diff --git a/core/core_bind.cpp b/core/core_bind.cpp
index 12a5d6aeaa5e..c09219d8a4b7 100644
--- a/core/core_bind.cpp
+++ b/core/core_bind.cpp
@@ -1666,16 +1666,7 @@ TypedArray<Dictionary> ClassDB::class_get_struct_list(const StringName &p_class,
 	TypedArray<Dictionary> ret;
 	::ClassDB::get_struct_list(p_class, &structs, p_no_inheritance);
 	for (const StructInfo &struct_info : structs) {
-		Dictionary struct_dict;
-		for (int i = 0; i < struct_info.count; i++) {
-			Dictionary member_dict;
-			member_dict[SNAME("name")] = struct_info.names[i];
-			member_dict[SNAME("type")] = struct_info.types[i];
-			member_dict[SNAME("class_name")] = struct_info.class_names[i];
-			member_dict[SNAME("default_value")] = struct_info.default_values[i];
-			struct_dict[struct_info.name] = member_dict;
-		}
-		ret.push_back(struct_dict);
+		ret.push_back(StructInfo::Layout::to_dict(struct_info));
 	}
 	return ret;
 }
@@ -1691,7 +1682,7 @@ TypedArray<Dictionary> ClassDB::class_get_struct_members(const StringName &p_cla
 		Dictionary dict;
 		dict[SNAME("name")] = struct_info->names[i];
 		dict[SNAME("type")] = struct_info->types[i];
-		dict[SNAME("class_name")] = struct_info->class_names[i];
+		dict[SNAME("type_name")] = struct_info->type_names[i];
 		dict[SNAME("default_value")] = struct_info->default_values[i];
 		ret.push_back(dict);
 	}
diff --git a/core/core_bind.h b/core/core_bind.h
index 1116bd02b01d..3257d34dd716 100644
--- a/core/core_bind.h
+++ b/core/core_bind.h
@@ -507,6 +507,7 @@ class ClassDB : public Object {
 
 	bool class_has_struct(const StringName &p_class, const StringName &p_struct, bool p_no_inheritance = false) const;
 	TypedArray<Dictionary> class_get_struct_list(const StringName &p_class, bool p_no_inheritance = false) const;
+	// TODO: class_get_struct_members seems kind of pointless. It should maybe just be class_get_struct or something.
 	TypedArray<Dictionary> class_get_struct_members(const StringName &p_class, const StringName &p_struct) const;
 
 #ifdef TOOLS_ENABLED
diff --git a/core/variant/array.cpp b/core/variant/array.cpp
index 5a5279f57d9a..cb0e1b9e0882 100644
--- a/core/variant/array.cpp
+++ b/core/variant/array.cpp
@@ -51,22 +51,18 @@ class ArrayPrivate {
 	ContainerTypeValidate typed;
 
 	_FORCE_INLINE_ bool is_struct() const {
-		return !typed.is_array_of_structs && typed.struct_info != nullptr;
+		return typed.get_is_struct();
 	}
 
 	_FORCE_INLINE_ bool is_array_of_structs() const {
-		return typed.is_array_of_structs;
-	}
-
-	_FORCE_INLINE_ bool is_struct_array() const {
-		return false; // TODO: not supported yet
+		return typed.is_array_of_structs();
 	}
 
 	_FORCE_INLINE_ int32_t find_member_index(const StringName &p_member) const {
 		// TODO: is there a better way to do this than linear search?
-		ERR_FAIL_NULL_V_MSG(typed.struct_info, -1, "Can only find member on a Struct");
-		for (int32_t i = 0; i < typed.struct_info->count; i++) {
-			if (p_member == typed.struct_info->names[i]) {
+		ERR_FAIL_COND_V_MSG(!typed.get_is_struct(), -1, "Can only find member on a Struct");
+		for (int32_t i = 0; i < typed.get_struct_info()->count; i++) {
+			if (p_member == typed.get_struct_info()->names[i]) {
 				return i;
 			}
 		}
@@ -75,9 +71,9 @@ class ArrayPrivate {
 
 	_FORCE_INLINE_ int32_t rfind_member_index(const StringName &p_member) const {
 		// TODO: is there a better way to do this than linear search?
-		ERR_FAIL_NULL_V_MSG(typed.struct_info, -1, "Can only find member on a Struct");
-		for (int32_t i = typed.struct_info->count - 1; i >= 0; i--) {
-			if (p_member == typed.struct_info->names[i]) {
+		ERR_FAIL_COND_V_MSG(!typed.get_is_struct(), -1, "Can only find member on a Struct");
+		for (int32_t i = typed.get_struct_info()->count - 1; i >= 0; i--) {
+			if (p_member == typed.get_struct_info()->names[i]) {
 				return i;
 			}
 		}
@@ -250,6 +246,10 @@ void Array::operator=(const Array &p_array) {
 	_ref(p_array);
 }
 
+bool Array::can_reference(const Array &p_array) const {
+	return _p->typed.can_reference(p_array._p->typed);
+}
+
 void Array::assign(const Array &p_array) {
 	const ContainerTypeValidate &typed = _p->typed;
 	const ContainerTypeValidate &source_typed = p_array._p->typed;
@@ -363,7 +363,7 @@ Error Array::resize(int p_new_size) {
 	if (err || variant_type == Variant::NIL || variant_type == Variant::OBJECT) {
 		return err;
 	}
-	if (const StructInfo *info = _p->typed.struct_info) { // Typed array of structs
+	if (const StructInfo *info = _p->typed.get_struct_info()) { // Typed array of structs
 		for (int i = old_size; i < p_new_size; i++) {
 			_p->array.write[i] = Array(*info);
 		}
@@ -603,7 +603,7 @@ const Variant &Array::get_named(const StringName &p_member) const {
 
 const StringName Array::get_member_name(int p_idx) const {
 	// TODO: probably need some error handling here.
-	return _p->typed.struct_info->names[p_idx];
+	return _p->typed.get_struct_info()->names[p_idx];
 }
 
 int Array::find_member(const StringName &p_member) const {
@@ -629,7 +629,7 @@ Array Array::duplicate(bool p_deep) const {
 Array Array::recursive_duplicate(bool p_deep, int recursion_count) const {
 	Array new_arr;
 	if (const StructInfo *struct_info = get_struct_info()) {
-		new_arr.set_struct(*struct_info, is_array_of_structs());
+		new_arr.set_struct(*struct_info, is_struct());
 	} else {
 		new_arr._p->typed = _p->typed;
 		if (p_deep) {
@@ -1002,13 +1002,13 @@ void Array::set_typed(uint32_t p_type, const StringName &p_class_name, const Var
 	_p->typed = ContainerTypeValidate(Variant::Type(p_type), p_class_name, script, "TypedArray");
 }
 
-void Array::set_struct(const StructInfo &p_struct_info, bool p_is_array_of_structs) {
+void Array::set_struct(const StructInfo &p_struct_info, bool p_is_struct) {
 	if (validate_set_type() != OK) {
 		return;
 	}
 	const int32_t size = p_struct_info.count;
 	_p->array.resize(size);
-	_p->typed = ContainerTypeValidate(p_struct_info, p_is_array_of_structs);
+	_p->typed = ContainerTypeValidate(p_struct_info, p_is_struct);
 }
 
 void Array::initialize_typed(uint32_t p_type, const StringName &p_class_name, const Variant &p_script) {
@@ -1019,11 +1019,11 @@ void Array::initialize_typed(uint32_t p_type, const StringName &p_class_name, co
 	_p->typed = ContainerTypeValidate(Variant::Type(p_type), p_class_name, script, "TypedArray");
 }
 
-void Array::initialize_struct_type(const StructInfo &p_struct_info, bool is_array_of_structs) {
-	if (!is_array_of_structs) {
+void Array::initialize_struct_type(const StructInfo &p_struct_info, bool p_is_struct) {
+	if (p_is_struct) {
 		_p->array.resize(p_struct_info.count);
 	}
-	_p->typed = ContainerTypeValidate(p_struct_info, is_array_of_structs);
+	_p->typed = ContainerTypeValidate(p_struct_info, p_is_struct);
 }
 
 bool Array::is_typed() const {
@@ -1059,7 +1059,7 @@ Variant Array::get_typed_script() const {
 }
 
 const StructInfo *Array::get_struct_info() const {
-	return _p->typed.struct_info;
+	return _p->typed.get_struct_info();
 }
 
 Array Array::create_read_only() {
@@ -1087,7 +1087,7 @@ Array::Array(const Array &p_from, const StructInfo &p_struct_info) {
 	_p = memnew(ArrayPrivate);
 	_p->refcount.init(); // TODO: should this be _ref(p_from)?
 
-	initialize_struct_type(p_struct_info, p_from.is_array_of_structs());
+	initialize_struct_type(p_struct_info, true);
 	assign(p_from);
 }
 
@@ -1095,19 +1095,19 @@ Array::Array(const Dictionary &p_from, const StructInfo &p_struct_info) {
 	_p = memnew(ArrayPrivate);
 	_p->refcount.init(); // TODO: should this be _ref(p_from)?
 
-	initialize_struct_type(p_struct_info, false);
+	initialize_struct_type(p_struct_info, true);
 	Variant *pw = _p->array.ptrw();
 	for (int32_t i = 0; i < p_struct_info.count; i++) {
 		pw[i] = p_from.has(p_struct_info.names[i]) ? p_from[p_struct_info.names[i]] : p_struct_info.default_values[i];
 	}
 }
 
-Array::Array(const StructInfo &p_struct_info, bool is_array_of_structs) {
+Array::Array(const StructInfo &p_struct_info, bool p_is_struct) {
 	_p = memnew(ArrayPrivate);
 	_p->refcount.init();
 
-	initialize_struct_type(p_struct_info, is_array_of_structs);
-	if (!is_array_of_structs) {
+	initialize_struct_type(p_struct_info, p_is_struct);
+	if (p_is_struct) {
 		Variant *pw = _p->array.ptrw();
 		for (int32_t i = 0; i < p_struct_info.count; i++) {
 			pw[i] = p_struct_info.default_values[i].duplicate(true);
diff --git a/core/variant/array.h b/core/variant/array.h
index 40f05abe2546..7cd883bbe1c6 100644
--- a/core/variant/array.h
+++ b/core/variant/array.h
@@ -42,7 +42,6 @@ class StringName;
 class Callable;
 template <typename T>
 class Vector;
-struct StructMember;
 struct ContainerTypeValidate;
 struct StructInfo;
 class Dictionary;
@@ -144,6 +143,7 @@ class Array {
 	uint32_t recursive_hash(int recursion_count) const;
 	void operator=(const Array &p_array);
 
+	bool can_reference(const Array &p_array) const;
 	void assign(const Array &p_array);
 	void push_back(const Variant &p_value);
 	_FORCE_INLINE_ void append(const Variant &p_value) { push_back(p_value); } //for python compatibility
@@ -201,11 +201,11 @@ class Array {
 
 	Error validate_set_type();
 	void set_typed(uint32_t p_type, const StringName &p_class_name, const Variant &p_script);
-	void set_struct(const StructInfo &p_struct_info, bool p_is_array_of_structs = false);
+	void set_struct(const StructInfo &p_struct_info, bool p_is_struct = true);
 
 protected:
 	void initialize_typed(uint32_t p_type, const StringName &p_class_name, const Variant &p_script);
-	void initialize_struct_type(const StructInfo &p_struct_info, bool p_is_array_of_structs = false);
+	void initialize_struct_type(const StructInfo &p_struct_info, bool p_is_struct = true);
 
 public:
 	bool is_typed() const;
@@ -226,7 +226,7 @@ class Array {
 	Array(const Array &p_from);
 	Array(const Array &p_from, const StructInfo &p_struct_info);
 	Array(const Dictionary &p_from, const StructInfo &p_struct_info);
-	Array(const StructInfo &p_struct_info, bool p_is_array_of_structs = false);
+	Array(const StructInfo &p_struct_info, bool p_is_struct = true);
 	Array();
 	~Array();
 };
diff --git a/core/variant/container_type_validate.h b/core/variant/container_type_validate.h
index 13df8c9fdd01..92803148c80d 100644
--- a/core/variant/container_type_validate.h
+++ b/core/variant/container_type_validate.h
@@ -39,9 +39,8 @@ struct ValidatedVariant {
 	Variant value;
 	bool valid;
 
-	ValidatedVariant(const Variant &p_value, const bool p_valid) {
-		value = p_value;
-		valid = p_valid;
+	ValidatedVariant(const Variant &p_value, const bool p_valid) :
+			value(p_value), valid(p_valid) {
 	}
 };
 
@@ -50,25 +49,37 @@ struct ContainerTypeValidate {
 	StringName class_name;
 	Ref<Script> script;
 
-	bool is_array_of_structs = false;
-	const StructInfo *struct_info = nullptr; // TODO: if is_array_of_structs == true, then require struct_info != nullptr, but not sure the best way to enforce this.
 	const char *where = "container";
 
+private:
+	// is_struct must be false if struct_info == nullptr
+	// if is_struct is false and struct_info != nullptr, the container is a TypedArray of Structs.
+	bool is_struct = false;
+	const StructInfo *struct_info = nullptr;
+
+public:
 	ContainerTypeValidate() {};
-	ContainerTypeValidate(const Variant::Type p_type, const StringName &p_class_name, const Ref<Script> &p_script, const char *p_where = "container") {
-		type = p_type;
-		class_name = p_class_name;
-		script = p_script;
-		struct_info = nullptr;
-		where = p_where;
+	ContainerTypeValidate(const Variant::Type p_type, const StringName &p_class_name, const Ref<Script> &p_script, const char *p_where = "container") :
+			type(p_type), class_name(p_class_name), script(p_script), where(p_where) {
+	}
+	ContainerTypeValidate(const StructInfo &p_struct_info, bool p_is_struct = true) :
+			type(Variant::ARRAY), class_name(p_struct_info.name), script(Ref<Script>()), where(p_is_struct ? "Struct" : "TypedArray"), struct_info(&p_struct_info), is_struct(p_is_struct) {
+	}
+
+	_FORCE_INLINE_ void set_struct_info(const StructInfo *p_struct_info) {
+		struct_info = p_struct_info;
+		if (!struct_info) {
+			is_struct = false;
+		}
+	}
+	_FORCE_INLINE_ const StructInfo *get_struct_info() const {
+		return struct_info;
 	}
-	ContainerTypeValidate(const StructInfo &p_struct_info, bool p_is_array_of_structs = false) {
-		type = Variant::ARRAY;
-		class_name = p_struct_info.name;
-		script = Ref<Script>();
-		is_array_of_structs = p_is_array_of_structs;
-		struct_info = &p_struct_info;
-		where = p_is_array_of_structs ? "TypedArray" : "Struct";
+	_FORCE_INLINE_ bool get_is_struct() const {
+		return is_struct;
+	}
+	_FORCE_INLINE_ bool is_array_of_structs() const {
+		return !is_struct && struct_info != nullptr;
 	}
 
 	_FORCE_INLINE_ bool can_reference(const ContainerTypeValidate &p_type) const {
@@ -78,7 +89,7 @@ struct ContainerTypeValidate {
 		if (type != p_type.type) {
 			return false;
 		}
-		if (is_array_of_structs != p_type.is_array_of_structs) {
+		if (is_struct != p_type.is_struct) {
 			return false;
 		}
 		if (!StructInfo::is_compatible(struct_info, p_type.struct_info)) {
@@ -108,10 +119,10 @@ struct ContainerTypeValidate {
 	}
 
 	_FORCE_INLINE_ bool operator==(const ContainerTypeValidate &p_type) const {
-		return type == p_type.type && class_name == p_type.class_name && script == p_type.script && is_array_of_structs == p_type.is_array_of_structs && StructInfo::is_compatible(struct_info, p_type.struct_info);
+		return type == p_type.type && class_name == p_type.class_name && script == p_type.script && is_struct == p_type.is_struct && StructInfo::is_compatible(struct_info, p_type.struct_info);
 	}
 	_FORCE_INLINE_ bool operator!=(const ContainerTypeValidate &p_type) const {
-		return type != p_type.type || class_name != p_type.class_name || script != p_type.script || is_array_of_structs != p_type.is_array_of_structs || !StructInfo::is_compatible(struct_info, p_type.struct_info);
+		return type != p_type.type || class_name != p_type.class_name || script != p_type.script || is_struct != p_type.is_struct || !StructInfo::is_compatible(struct_info, p_type.struct_info);
 	}
 
 	_FORCE_INLINE_ static ValidatedVariant validate_variant_type(const Variant::Type p_type, const Variant &p_variant, const char *p_where, const char *p_operation = "use") {
@@ -185,8 +196,8 @@ struct ContainerTypeValidate {
 		if (!ret.valid) {
 			return ret;
 		}
-
 		// Variant types match
+
 		if (type == Variant::ARRAY) {
 			const Array array = p_variant;
 			if (array.is_struct()) { // validating a struct into a typed array of structs
@@ -209,16 +220,26 @@ struct ContainerTypeValidate {
 		if (!ret.valid) {
 			return ret;
 		}
-
 		// Variant types match
-		if (variant_type == Variant::ARRAY) {
-			const Array array = p_variant;
-			// Valid if (the struct member is itself a struct and the other array is a compatible struct) or (neither the struct member nor the other array are a struct).
-			ret.valid = StructInfo::is_compatible(struct_info->struct_member_infos[p_struct_index], array.get_struct_info());
-		} else if (variant_type == Variant::OBJECT) {
-			ret.valid = validate_object(struct_info->class_names[p_struct_index], Ref<Script>(), p_variant, where, p_operation);
+
+		switch (variant_type) {
+			case Variant::ARRAY: {
+				const Array &default_array = struct_info->default_values[p_struct_index];
+				ret.valid = default_array.can_reference(p_variant);
+				return ret;
+			}
+			case Variant::DICTIONARY: {
+				const Dictionary &default_dict = struct_info->default_values[p_struct_index];
+				ret.valid = default_dict.can_reference(p_variant);
+				return ret;
+			}
+			case Variant::OBJECT: {
+				ret.valid = validate_object(struct_info->type_names[p_struct_index], static_cast<Ref<Script>>(struct_info->scripts[p_struct_index]), p_variant, where, p_operation);
+				return ret;
+			}
+			default:
+				return ret;
 		}
-		return ret;
 	}
 };
 
diff --git a/core/variant/dictionary.cpp b/core/variant/dictionary.cpp
index c530acdb2503..15accb9450a9 100644
--- a/core/variant/dictionary.cpp
+++ b/core/variant/dictionary.cpp
@@ -395,6 +395,10 @@ Array Dictionary::values() const {
 	return varr;
 }
 
+bool Dictionary::can_reference(const Dictionary &p_dictionary) const {
+	return _p->typed_key.can_reference(p_dictionary._p->typed_key) && _p->typed_value.can_reference(p_dictionary._p->typed_value);
+}
+
 void Dictionary::assign(const Dictionary &p_dictionary) {
 	const ContainerTypeValidate &typed_key = _p->typed_key;
 	const ContainerTypeValidate &typed_key_source = p_dictionary._p->typed_key;
diff --git a/core/variant/dictionary.h b/core/variant/dictionary.h
index 06799c29acf3..a1da7f5158d1 100644
--- a/core/variant/dictionary.h
+++ b/core/variant/dictionary.h
@@ -82,6 +82,7 @@ class Dictionary {
 	uint32_t recursive_hash(int recursion_count) const;
 	void operator=(const Dictionary &p_dictionary);
 
+	bool can_reference(const Dictionary &p_dictionary) const;
 	void assign(const Dictionary &p_dictionary);
 	const Variant *next(const Variant *p_key = nullptr) const;
 
diff --git a/core/variant/struct.h b/core/variant/struct.h
index 7c4c8c6fc83c..c31e3e28e7df 100644
--- a/core/variant/struct.h
+++ b/core/variant/struct.h
@@ -130,7 +130,7 @@ struct GetTypeInfo<Struct<T>> {
 	static const Variant::Type VARIANT_TYPE = Variant::ARRAY;
 	static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;
 	static PropertyInfo get_class_info() {
-		return PropertyInfo(Variant::ARRAY, String(), PROPERTY_HINT_ARRAY_TYPE, T::Layout::get_struct_name());
+		return PropertyInfo(Variant::ARRAY, String(), PROPERTY_HINT_ARRAY_TYPE, T::get_struct_name());
 	}
 };
 
@@ -139,7 +139,7 @@ struct GetTypeInfo<const Struct<T> &> {
 	static const Variant::Type VARIANT_TYPE = Variant::ARRAY;
 	static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;
 	static PropertyInfo get_class_info() {
-		return PropertyInfo(Variant::ARRAY, String(), PROPERTY_HINT_ARRAY_TYPE, T::Layout::get_struct_name());
+		return PropertyInfo(Variant::ARRAY, String(), PROPERTY_HINT_ARRAY_TYPE, T::get_struct_name());
 	}
 };
 
diff --git a/core/variant/struct_generator.cpp b/core/variant/struct_generator.cpp
index 528255288354..dbf3d68ca9aa 100644
--- a/core/variant/struct_generator.cpp
+++ b/core/variant/struct_generator.cpp
@@ -30,13 +30,15 @@
 
 #include "struct_generator.h"
 
+#include "core/object/script_language.h"
 #include "core/variant/struct.h"
 #include "core/variant/typed_array.h"
 
 Variant StructInfo::types::to_variant(const Vector<Variant::Type> &p_value) {
 	PackedInt32Array packed_types;
-	packed_types.resize(p_value.size());
-	for (int i = 0; i < p_value.size(); i++) {
+	const Vector<Variant::Type>::Size size = p_value.size();
+	packed_types.resize(size);
+	for (int i = 0; i < size; i++) {
 		packed_types.write[i] = p_value[i];
 	}
 	return packed_types;
@@ -45,35 +47,33 @@ Variant StructInfo::types::to_variant(const Vector<Variant::Type> &p_value) {
 Vector<Variant::Type> StructInfo::types::from_variant(const Variant &p_variant) {
 	const PackedInt32Array &packed_types = p_variant;
 	Vector<Variant::Type> types;
-	types.resize(packed_types.size());
-	for (int i = 0; i < packed_types.size(); i++) {
+	const PackedInt32Array::Size size = packed_types.size();
+	types.resize(size);
+	for (int i = 0; i < size; i++) {
 		types.write[i] = static_cast<Variant::Type>(packed_types[i]);
 	}
 	return types;
 }
 
-Dictionary StructInfo::to_dict() const {
-	Dictionary dict;
-	dict["name"] = name;
-	dict["count"] = count;
-	dict["names"] = names;
-	PackedInt32Array packed_types;
-	packed_types.resize(count);
-	for (int i = 0; i < count; i++) {
-		packed_types.write[i] = types[i];
+Variant StructInfo::scripts::to_variant(const Vector<const Script *> &p_value) {
+	TypedArray<Script> scripts;
+	const Vector<const Script *>::Size size = p_value.size();
+	scripts.resize(size);
+	for (int i = 0; i < size; i++) {
+		scripts[i] = p_value[i];
 	}
-	dict["types"] = packed_types;
-	dict["class_names"] = class_names;
-	TypedArray<Dictionary> member_info_dictionaries;
-	member_info_dictionaries.resize(count);
-	for (int i = 0; i < count; i++) {
-		const StructInfo *member_info = struct_member_infos[i];
-		// TODO: Recursion limit?
-		member_info_dictionaries[i] = member_info ? member_info->to_dict() : Dictionary();
+	return scripts;
+}
+
+Vector<const Script *> StructInfo::scripts::from_variant(const Variant &p_variant) {
+	const TypedArray<Script> &script_array = p_variant;
+	Vector<const Script *> script_vector;
+	const int size = script_array.size();
+	script_vector.resize(size);
+	for (int i = 0; i < size; i++) {
+		script_vector.ptrw()[i] = static_cast<Ref<Script>>(script_array[i]).ptr();
 	}
-	dict["struct_member_infos"] = member_info_dictionaries;
-	dict["default_values"] = default_values;
-	return dict;
+	return script_vector;
 }
 
 // Needs to be in .cpp so struct.h can be included
diff --git a/core/variant/struct_generator.h b/core/variant/struct_generator.h
index 8816de97338c..3cafbee70f78 100644
--- a/core/variant/struct_generator.h
+++ b/core/variant/struct_generator.h
@@ -39,6 +39,8 @@ class TypedArray;
 template <typename T>
 class Struct;
 
+class Script;
+
 /* The following set of macros let you seamlessly add reflection data to
  * a C++ struct or class so that it can be exposed as a Godot Struct.
  * The StructInfo struct below uses these macros and serves as a good
@@ -88,8 +90,8 @@ class Struct;
 		_FORCE_INLINE_ static Variant to_variant(const m_type &p_value) { return p_value; }                 \
 		STRUCT_MEMBER_TYPEDEF_ALIAS(m_type, m_member_name, m_member_name_alias, m_default);                 \
 		_FORCE_INLINE_ static Variant::Type get_variant_type() { return to_variant(m_default).get_type(); } \
-		_FORCE_INLINE_ static const StringName get_class_name() { return StringName(); }                    \
-		static const StructInfo *get_struct_member_info() { return nullptr; }                               \
+		_FORCE_INLINE_ static StringName get_type_name() { return StringName(); }                           \
+		_FORCE_INLINE_ static const Script *get_script() { return nullptr; }                                \
 	}
 
 #define STRUCT_MEMBER(m_type, m_member_name, m_default) \
@@ -104,8 +106,8 @@ class Struct;
 		_FORCE_INLINE_ static Variant to_variant(const m_type &p_value) { return p_value; }                 \
 		STRUCT_MEMBER_TYPEDEF(m_type, m_member_name, m_default);                                            \
 		_FORCE_INLINE_ static Variant::Type get_variant_type() { return to_variant(m_default).get_type(); } \
-		_FORCE_INLINE_ static const StringName get_class_name() { return StringName(); }                    \
-		static const StructInfo *get_struct_member_info() { return nullptr; }                               \
+		_FORCE_INLINE_ static StringName get_type_name() { return StringName(); }                           \
+		_FORCE_INLINE_ static const Script *get_script() { return nullptr; }                                \
 	}
 
 // Macros that include _TO allow you to customize the way the struct is converted to a Variant. You must
@@ -117,8 +119,8 @@ class Struct;
 		static Variant to_variant(const m_type &p_value);                                                   \
 		STRUCT_MEMBER_TYPEDEF_ALIAS(m_type, m_member_name, m_member_name_alias, m_default);                 \
 		_FORCE_INLINE_ static Variant::Type get_variant_type() { return to_variant(m_default).get_type(); } \
-		_FORCE_INLINE_ static const StringName get_class_name() { return StringName(); }                    \
-		static const StructInfo *get_struct_member_info() { return nullptr; }                               \
+		_FORCE_INLINE_ static StringName get_type_name() { return StringName(); }                           \
+		_FORCE_INLINE_ static const Script *get_script() { return nullptr; }                                \
 	}
 
 #define STRUCT_MEMBER_FROM_TO(m_type, m_member_name, m_default) \
@@ -131,8 +133,8 @@ class Struct;
 		_FORCE_INLINE_ static Variant to_variant(m_type *p_value) { return p_value; }                                       \
 		STRUCT_MEMBER_TYPEDEF_POINTER(m_type, m_member_name, m_default);                                                    \
 		_FORCE_INLINE_ static Variant::Type get_variant_type() { return Variant::OBJECT; }                                  \
-		_FORCE_INLINE_ static const StringName get_class_name() { return SNAME(#m_type); }                                  \
-		static const StructInfo *get_struct_member_info() { return nullptr; }                                               \
+		_FORCE_INLINE_ static StringName get_type_name() { return SNAME(#m_type); }                                         \
+		_FORCE_INLINE_ static const Script *get_script() { return nullptr; }                                                \
 	}
 
 #define STRUCT_MEMBER_CLASS_VALUE(m_type, m_member_name, m_default)                               \
@@ -142,19 +144,19 @@ class Struct;
 		_FORCE_INLINE_ static Variant to_variant(const m_type &p_value) { return p_value; }       \
 		STRUCT_MEMBER_TYPEDEF(m_type, m_member_name, m_default);                                  \
 		_FORCE_INLINE_ static Variant::Type get_variant_type() { return Variant::OBJECT; }        \
-		_FORCE_INLINE_ static const StringName get_class_name() { return SNAME(#m_type); }        \
-		static const StructInfo *get_struct_member_info() { return nullptr; }                     \
+		_FORCE_INLINE_ static StringName get_type_name() { return SNAME(#m_type); }               \
+		_FORCE_INLINE_ static const Script *get_script() { return nullptr; }                      \
 	}
 
-#define STRUCT_MEMBER_STRUCT(m_type, m_member_name, m_default)                                                          \
-	m_type m_member_name = m_default;                                                                                   \
-	struct m_member_name {                                                                                              \
-		_FORCE_INLINE_ static m_type from_variant(const Variant &p_variant) { return Struct<m_type>(p_variant); }       \
-		_FORCE_INLINE_ static Variant to_variant(const m_type &p_value) { return Struct<m_type>(p_value); }             \
-		STRUCT_MEMBER_TYPEDEF(m_type, m_member_name, m_default);                                                        \
-		_FORCE_INLINE_ static Variant::Type get_variant_type() { return Variant::ARRAY; }                               \
-		_FORCE_INLINE_ static const StringName get_class_name() { return StringName(); }                                \
-		_FORCE_INLINE_ static const StructInfo *get_struct_member_info() { return &m_type::Layout::get_struct_info(); } \
+#define STRUCT_MEMBER_STRUCT(m_type, m_member_name, m_default)                                                    \
+	m_type m_member_name = m_default;                                                                             \
+	struct m_member_name {                                                                                        \
+		_FORCE_INLINE_ static m_type from_variant(const Variant &p_variant) { return Struct<m_type>(p_variant); } \
+		_FORCE_INLINE_ static Variant to_variant(const m_type &p_value) { return Struct<m_type>(p_value); }       \
+		STRUCT_MEMBER_TYPEDEF(m_type, m_member_name, m_default);                                                  \
+		_FORCE_INLINE_ static Variant::Type get_variant_type() { return Variant::ARRAY; }                         \
+		_FORCE_INLINE_ static StringName get_type_name() { return m_type::get_struct_name(); }                    \
+		_FORCE_INLINE_ static const Script *get_script() { return nullptr; }                                      \
 	}
 
 #define STRUCT_MEMBER_STRUCT_FROM_TO_ALIAS(m_type, m_member_name, m_member_name_alias, m_default) \
@@ -164,10 +166,8 @@ class Struct;
 		static Variant to_variant(const m_type &p_value);                                         \
 		STRUCT_MEMBER_TYPEDEF_ALIAS(m_type, m_member_name, m_member_name_alias, m_default);       \
 		_FORCE_INLINE_ static Variant::Type get_variant_type() { return Variant::ARRAY; }         \
-		_FORCE_INLINE_ static const StringName get_class_name() { return StringName(); }          \
-		_FORCE_INLINE_ static const StructInfo *get_struct_member_info() {                        \
-			return &m_type::Layout::get_struct_info();                                            \
-		}                                                                                         \
+		_FORCE_INLINE_ static StringName get_type_name() { return m_type::get_struct_name(); }    \
+		_FORCE_INLINE_ static const Script *get_script() { return nullptr; }                      \
 	}
 
 #define STRUCT_MEMBER_STRUCT_FROM_TO(m_type, m_member_name, m_default) \
@@ -206,10 +206,10 @@ struct StructLayout {
 	_FORCE_INLINE_ static const StructInfo &get_struct_info() {
 		static const Vector<StringName> names = { StructMembers::get_name()... };
 		static const Vector<Variant::Type> types = { StructMembers::get_variant_type()... };
-		static const Vector<StringName> class_names = { StructMembers::get_class_name()... };
-		static const Vector<const StructInfo *> struct_member_infos = { StructMembers::get_struct_member_info()... };
+		static const Vector<StringName> type_names = { StructMembers::get_type_name()... };
+		static const Vector<const Script *> scripts = { StructMembers::get_script()... };
 		static const Vector<Variant> default_values = { StructMembers::get_default_value_variant()... };
-		static const StructInfo info = StructInfo(get_struct_name(), struct_member_count, names, types, class_names, struct_member_infos, default_values);
+		static const StructInfo info = StructInfo(get_struct_name(), struct_member_count, names, types, type_names, scripts, default_values);
 		return info;
 	}
 
@@ -283,37 +283,34 @@ struct StructInfo {
 	STRUCT_MEMBER(int32_t, count, 0);
 	STRUCT_MEMBER(Vector<StringName>, names, Vector<StringName>());
 	STRUCT_MEMBER_FROM_TO(Vector<Variant::Type>, types, Vector<Variant::Type>());
-	STRUCT_MEMBER(Vector<StringName>, class_names, Vector<StringName>());
+	STRUCT_MEMBER(Vector<StringName>, type_names, Vector<StringName>());
+	STRUCT_MEMBER_FROM_TO(Vector<const Script *>, scripts, Vector<const Script *>()); // wants to be Vector<Ref<Script>> but can't include Ref here.
 	STRUCT_MEMBER(Vector<Variant>, default_values, Vector<Variant>());
-	STRUCT_LAYOUT_ALIAS("StructInfo", StructInfo, struct name, struct count, struct names, struct types, struct class_names, struct default_values);
-
-	Vector<const StructInfo *> struct_member_infos;
+	STRUCT_LAYOUT_ALIAS("StructInfo", StructInfo, struct name, struct count, struct names, struct types, struct type_names, struct scripts, struct default_values);
 
 	StructInfo() {};
 	StructInfo(const StringName &p_name, const int32_t p_count) :
 			name(p_name), count(p_count) {
 		names.resize(p_count);
 		types.resize(p_count);
-		class_names.resize(p_count);
-		struct_member_infos.resize(p_count);
+		type_names.resize(p_count);
+		scripts.resize(p_count);
 		default_values.resize(p_count);
 	}
-	StructInfo(const StringName &p_name, const int32_t p_count, const Vector<StringName> &p_names, const Vector<Variant::Type> &p_types, const Vector<StringName> &p_class_names, const Vector<const StructInfo *> &p_struct_member_infos, const Vector<Variant> &p_default_values) :
+	StructInfo(const StringName &p_name, const int32_t p_count, const Vector<StringName> &p_names, const Vector<Variant::Type> &p_types, const Vector<StringName> &p_type_names, const Vector<const Script *> &p_scripts, const Vector<Variant> &p_default_values) :
 			name(p_name),
 			count(p_count),
 			names(p_names),
 			types(p_types),
-			class_names(p_class_names),
-			struct_member_infos(p_struct_member_infos),
+			type_names(p_type_names),
+			scripts(p_scripts),
 			default_values(p_default_values) {};
 
-	Dictionary to_dict() const;
-
-	_FORCE_INLINE_ void set(int32_t p_index, const StringName &p_name, const Variant::Type &p_type, const StringName &p_class_name, const StructInfo *p_struct_member_info, const Variant &p_default_value) {
+	_FORCE_INLINE_ void set(int32_t p_index, const StringName &p_name, const Variant::Type &p_type, const StringName &p_type_name, const Script *p_script, const Variant &p_default_value) {
 		names.write[p_index] = p_name;
 		types.write[p_index] = p_type;
-		class_names.write[p_index] = p_class_name;
-		struct_member_infos.write[p_index] = p_struct_member_info;
+		type_names.write[p_index] = p_type_name;
+		scripts.write[p_index] = p_script;
 		default_values.write[p_index] = p_default_value;
 	}
 
diff --git a/core/variant/typed_array.h b/core/variant/typed_array.h
index 7cada0e2f705..d0de04e72a4e 100644
--- a/core/variant/typed_array.h
+++ b/core/variant/typed_array.h
@@ -86,10 +86,10 @@ class TypedArray<Struct<T>> : public Array {
 			Array(p_array.is_array_of_structs() ? p_array : Array({ p_array }, T::get_struct_info()), T::get_struct_info()) {
 	}
 	_FORCE_INLINE_ TypedArray() {
-		initialize_struct_type(T::get_struct_info(), true);
+		initialize_struct_type(T::get_struct_info(), false);
 	}
 	_FORCE_INLINE_ TypedArray(const List<T> *p_list) {
-		initialize_struct_type(T::get_struct_info(), true);
+		initialize_struct_type(T::get_struct_info(), false);
 		for (const typename List<T>::Element *E = p_list->front(); E; E = E->next()) {
 			push_back(Struct<T>(E->get()));
 		}
diff --git a/core/variant/variant_setget.cpp b/core/variant/variant_setget.cpp
index 0524821faca2..c957005975c0 100644
--- a/core/variant/variant_setget.cpp
+++ b/core/variant/variant_setget.cpp
@@ -1301,7 +1301,7 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const {
 			if (array->is_struct()) {
 				const StructInfo *struct_info = array->get_struct_info();
 				for (int32_t i = 0; i < struct_info->count; i++) {
-					p_list->push_back(PropertyInfo(struct_info->types[i], struct_info->names[i], PropertyHint::PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT, struct_info->class_names[i]));
+					p_list->push_back(PropertyInfo(struct_info->types[i], struct_info->names[i], PropertyHint::PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT, struct_info->type_names[i]));
 				}
 				break;
 			}
diff --git a/tests/core/variant/test_struct.h b/tests/core/variant/test_struct.h
index 2c54a7fbf19b..6619b6d5654a 100644
--- a/tests/core/variant/test_struct.h
+++ b/tests/core/variant/test_struct.h
@@ -238,7 +238,7 @@ TEST_CASE("[Struct] StructInfo") {
 		CHECK_EQ(info_as_c_struct.count, info_as_godot_struct.get_member<struct StructInfo::count>());
 		CHECK_EQ(info_as_c_struct.names, info_as_godot_struct.get_member<struct StructInfo::names>());
 		CHECK_EQ(info_as_c_struct.types, info_as_godot_struct.get_member<struct StructInfo::types>());
-		CHECK_EQ(info_as_c_struct.class_names, info_as_godot_struct.get_member<struct StructInfo::class_names>());
+		CHECK_EQ(info_as_c_struct.type_names, info_as_godot_struct.get_member<struct StructInfo::type_names>());
 		CHECK_EQ(info_as_c_struct.default_values, info_as_godot_struct.get_member<struct StructInfo::default_values>());
 	}
 
@@ -348,8 +348,6 @@ TEST_CASE("[Struct] Nesting") {
 	};
 
 	REQUIRE_EQ(NestedStruct::Layout::struct_member_count, 2);
-	CHECK_EQ(NestedStruct::Layout::get_struct_info().struct_member_infos[0], nullptr);
-	CHECK_EQ(NestedStruct::Layout::get_struct_info().struct_member_infos[1]->count, 2);
 
 	Struct<BasicStruct> basic_struct;
 	Struct<BasicStructLookalike> basic_struct_lookalike;
@@ -425,7 +423,7 @@ TEST_CASE("[Struct] ClassDB") {
 	CHECK_EQ(struct_info->name, "Object.PropertyInfo");
 	CHECK_EQ(struct_info->names[3], "hint");
 	CHECK_EQ(struct_info->types[3], Variant::INT);
-	CHECK_EQ(struct_info->class_names[3], "");
+	CHECK_EQ(struct_info->type_names[3], "");
 	CHECK_EQ((int)struct_info->default_values[3], PROPERTY_HINT_NONE);
 }